diff --git a/.gitignore b/.gitignore index 41faf70..b876876 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ /target vtk-rs/libvtkrs/build Cargo.lock +LEARNINGS.md +WORKFLOW.md \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..72ba791 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,49 @@ +## [0.3.0] - 2026-05-29 +This change will introduce the new feature of automatically creating the hierarchy. Additionally, tests were added for all the core functionalities of `vtk-gen` (not complete for possible edge cases, focused on straight forward functionality assessment). Most other changes are a result of getting everything to build without errors (e.g. handling rust keywords, handling different cpp pointers, ...). + +Detailed summary: + +### Added +- `vtkFiltersSources` module is now generated and linked, adding `SphereSource` and 20+ other source classes. +- Re-export all constructable VTK classes at the crate root with the `vtk` prefix stripped (e.g. `vtk_rs::SphereSource`, `vtk_rs::NamedColors`). +- `pub mod prelude` in the generated `lib.rs` that re-exports all module contents via glob, enabling `use vtk_rs::prelude::*` for ergonomic trait method access without explicit trait imports. +- `sphere_source` example in `examples/` (workspace root), runnable via `cargo run --example sphere_source`. +- `has_ancestor(class_name, target) -> bool` on `ClassHierarchy` -> iterative DFS to walk the full ancestor chain (not just direct parents). Used to correctly detect `vtkObjectBase` ancestry across deep inheritance hierarchies. +- `IRStruct::has_vtk_object_base_ancestor: bool` field, computed via `has_ancestor` rather than checking direct parents only, fixing `is_constructable()` for deeply inherited classes. +- `IRMethod::vtk_name: String` field (PascalCase VTK method name) and `short_name()` helper for generating clean Rust method names. +- `c_signed_char` IR type to distinguish VTK's explicitly-typed `signed char` (used in typed data arrays such as `vtkSignedCharArray`) from plain `char` (used for C strings). `CppType::PlainChar` added to the C++ parser for the same reason. +- Overload deduplication via `.scan()` in `IRModule::new()`: C does not support overloading, so only the first VTK overload seen for each binding name is kept. +- `StarStarConst` (`**const`) and `StarStarStar` (`***`) pointer variants added to the `Pointer` enum in `parse_wrap_vtk_xml`. +- `pointer: Option` field added to `Parameter` in `parse_wrap_vtk_xml` so parameter pointer qualifiers are no longer silently dropped. +- C-style array parameter filter in `get_exposable_methods`: methods whose signature contains `[` are skipped because array extents are not encoded in the WrapVTK XML. +- Comprehensive test suites: `#[cfg(test)] mod inheritance_tests` (5 tests), `mod gen_rust_tests` (20 tests), `mod gen_cpp_tests` (8 tests), `mod tests` in `intermediate_representation` (5 tests). Total: 52 vtk-gen unit tests. + +### Changed +- `is_constructable()` now requires `has_vtk_object_base_ancestor` (full ancestor chain) instead of checking only direct parents for `vtkObjectBase`. +- `method_to_cpp` / `method_to_cpp_header` emit `extern "C"` bindings using `method.vtk_name` for the C++ call site and `method.name` for the symbol name. +- The glob processed by vtk-gen now includes `vtkFiltersSources` in addition to `vtkCommon*`. +- `write_build_rs` in `vtk-gen/src/main.rs` no longer hardcodes `vtktoken` in the link list (VTK 9.1 system packages do not ship `libvtktoken`). + +### Fixed +- **`vtkNew` ABI mismatch in generated C++ wrappers**: `vtkNew` has a non-trivial destructor, so passing or returning it by value in `extern "C"` functions violates the x86-64 SysV ABI and causes the wrapped VTK object to be destroyed on every method call. Constructor, destructor, get-ptr, and all method wrappers now use raw `T*` (`T::New()` / `sself->Delete()` / `return sself`) instead of `vtkNew`. +- **`std::string` return types** (`IRType::String`): bridging `std::string` as `const char*` is illegal (dangling pointer). These methods are now skipped on both the Rust and C++ sides. +- **`const char*` vs `const char* const*`**: `StarStarConst` and `StarStar` now always bail instead of incorrectly reducing to a single pointer. +- **Mutable `char**` output parameters**: `StarStar` always bails -> VTK_FILEPATH uses `pointer="*"` in the actual XML, never `pointer="**"`. The previous special-case for `Const(SignedChar)**` was unreachable dead code and has been removed. +- **Mutable `char*` vs `signed char*`**: `Pointer(c_char)` (without `Const`) is now rejected on both Rust and C++ sides — VTK typed-data-array methods use `signed char*`, which is not implicitly convertible from `char*` in C++. +- **`signed char*` data array methods**: Separated `CppType::PlainChar` (`"char"`) from `CppType::SignedChar` (`"signed char"`) so typed-data-array parameters (`const signed char*`) generate the correct C++ type and are rejected at the Rust FFI boundary (not safely bridgeable without element-count information). +- **`Path` types by value/reference** (e.g. `const vtkStdString&`, `vtkColor3ub`): rejected in `ir_type_is_supported`; VTK object types are only bridgeable as opaque pointers. +- **Heap collection types** (`Vec`, `LinkedList`, `Map`): rejected in `ir_type_is_supported` — these types cannot cross the `extern "C"` boundary safely. +- **Cross-module supertrait bounds**: removed from generated trait definitions. Generating `trait VtkFoo: VtkBar` across module boundaries requires the concrete struct to implement all ancestor traits, which the generator does not yet support. +- **`vtktoken` linker error**: removed from the hardcoded link list in `write_build_rs`; `libvtktoken` is a VTK 9.2+ library not present in VTK 9.1 system packages. +- **`c_longlong` Rust type mapping**: was incorrectly emitting `core::ffi::c_uchar` (copy-paste error); now correctly emits `core::ffi::c_longlong`. +- **Generated `test_vtkXxx_create_drop` was broken**: after the `vtkNew` → `T*` switch, `get_ptr` returns the pointer itself so the post-drop null assertion was wrong and the test accessed freed memory (UB). Simplified to verify creation gives a non-null pointer and `drop` does not panic. +- **Panic in `get_exposable_methods`**: indexing `self.classes[parent]` would panic if a parent class named in an XML `` entry had no corresponding XML file scanned. Changed to a silent skip via `.filter_map(|n| self.classes.get(&n))`. +- **`new()` in generated bindings**: `Self(unsafe { &mut *constructor() })` created a spurious `&mut c_void` reference before coercing back to `*mut c_void`. Simplified to `Self(unsafe { constructor() })`. + +## [0.2.0] - 2025-06-03 + +## [0.1.3] - 2025-05-25 + +## [0.1.2] - 2025-05-24 + +## [0.1.1] - 2025-04-01 \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 14ffb74..60bd557 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,4 +1,5 @@ [workspace] +resolver = "3" members = [ "vtk-gen", "vtk-rs-9.1", diff --git a/README.md b/README.md index 1e3a669..71e88c9 100644 --- a/README.md +++ b/README.md @@ -61,6 +61,74 @@ However, we do not use `cxx` to compile the code but rather let `cmake` handle t To implement the desired class methods, we use Rust [macros](https://doc.rust-lang.org/reference/macros-by-example.html). +## Contributing / Development Setup + +This section is for contributors who want to regenerate bindings for a new VTK version. +If you only want to *use* the existing `vtk-rs-9.1` bindings, skip this section since a system VTK install and `cargo build` is sufficient. + +### Prerequisites + +Before following the steps below, ensure you have the following tools installed: + +| Tool | Required | Purpose | +| --- | --- | --- | +| `cmake` (≥ 3.12) | Yes | Build VTK from source and build WrapVTK | +| `git` | Yes | Clone the VTK source repository | +| C++ compiler (`gcc` or `clang`) | Yes | Compile VTK and WrapVTK | +| Python dev headers | Yes | Required by VTK's Python wrapping layer, which WrapVTK depends on to generate XML | +| `libarchive` dev headers | Optional | Enables the `vtkCommonArchive` module; skipped gracefully if absent | +| ~10 GB free disk space | Yes | VTK source clone + build artifacts | + +Install on Ubuntu 22 / 24: +```bash +# Required +sudo apt install cmake build-essential python3-dev +# Optional (for vtkCommonArchive) +sudo apt install libarchive-dev +``` +Install on Arch Linux: +```bash +sudo pacman -S cmake gcc python libarchive +``` +Install on macOS: +```bash +brew install cmake python libarchive +``` + +### 1. Run the setup script + +`libvtk9-dev` (the system package) does **not** install the internal wrapping tool headers (e.g. `vtkParseAttributes.h`) that WrapVTK needs. +Use the provided `setup_vtk.sh` script to clone VTK from source, build it, initialise the `WrapVTK` submodule if needed, build WrapVTK against it, and verify the XML output all in one step: + +```bash +./setup_vtk.sh 9.2.0 +``` + +The version argument is optional and defaults to `9.2.0`. This takes roughly 15–30 minutes depending on your machine. + +The script will: +1. Wipe any existing `~/VTK` clone and `WrapVTK/build` directory +2. Clone VTK at the exact tag (e.g. `v9.2.0`) into `~/VTK` +3. Build VTK with static libs, Python wrapping enabled (required by WrapVTK), and the non-Common groups disabled (Rendering, Imaging, Qt, Web, Views, MPI — not needed for XML generation, and some contain version-specific compile bugs) +4. Initialise the `WrapVTK` git submodule automatically if not already done +5. Build WrapVTK against the fresh VTK build +6. Verify that XML files were generated under `WrapVTK/build/xml/` + +### 2. Regenerate bindings with vtk-gen + +```bash +cargo run -p vtk-gen -- \ + --opath vtk-rs-9.2 \ + --wrap-vtk WrapVTK +``` +or one-line +```bash +cargo run -p vtk-gen -- --opath vtk-rs-9.2 --wrap-vtk WrapVTK +``` + +This regenerates all files in `vtk-rs-9.2/` from the WrapVTK XML output. +To target a different VTK version, run `./setup_vtk.sh ` first, then repeat this step with a matching output path (e.g. `--opath vtk-rs-9.1` as included in the repository). + ## Roadmap 1. [x] Stabilize Build system 2. [x] Automate system library detection and generate linker flags diff --git a/examples/sphere_source.rs b/examples/sphere_source.rs index 1e0d03a..bc3193e 100644 --- a/examples/sphere_source.rs +++ b/examples/sphere_source.rs @@ -1,17 +1,20 @@ use vtk_rs as vtk; +use vtk_rs::prelude::*; fn main() { - let colors = vtk::NamedColors::new(); + let _colors = vtk::NamedColors::new(); // Create a sphere let mut sphere_source = vtk::SphereSource::new(); - sphere_source.set_center([0.; 3]); + sphere_source.set_center(0., 0., 0.); sphere_source.set_radius(5.0); // Make the surface smooth sphere_source.set_phi_resolution(100); sphere_source.set_theta_resolution(100); + println!("sphere source: {sphere_source:?}") + /* let mut mapper = vtk::PolyDataMapper::new(); mapper.set_input_connection(sphere_source.get_output_port()); let mut mapper = vtkPolyDataMapper::New(); diff --git a/setup_vtk.sh b/setup_vtk.sh new file mode 100755 index 0000000..e299f1f --- /dev/null +++ b/setup_vtk.sh @@ -0,0 +1,177 @@ +#!/usr/bin/env bash +# setup_vtk.sh — Download VTK from source, build WrapVTK, and generate XML files. +# +# Usage: +# ./setup_vtk.sh [VTK_VERSION] +# +# Example: +# ./setup_vtk.sh 9.2.0 (default) +# ./setup_vtk.sh 9.3.0 +# +# What this script does: +# 1. Wipes any existing ~/VTK clone and WrapVTK/build directory. +# 2. Clones VTK at the exact tag v into ~/VTK. +# 3. Builds VTK (static libs, no Python/Java/testing). +# 4. Builds WrapVTK against the fresh VTK build. +# 5. Verifies that XML files were generated. + +set -euo pipefail + +# --------------------------------------------------------------------------- +# Configuration +# --------------------------------------------------------------------------- +VTK_VERSION="${1:-9.2.0}" +VTK_TAG="v${VTK_VERSION}" +VTK_SRC="${HOME}/VTK" +VTK_BUILD="${VTK_SRC}/build" +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +WRAP_VTK_DIR="${SCRIPT_DIR}/WrapVTK" +WRAP_BUILD="${WRAP_VTK_DIR}/build" +JOBS="$(nproc)" + +echo "==========================================" +echo " VTK setup script" +echo " VTK version : ${VTK_TAG}" +echo " VTK source : ${VTK_SRC}" +echo " WrapVTK dir : ${WRAP_VTK_DIR}" +echo " Parallel jobs: ${JOBS}" +echo "==========================================" + +# --------------------------------------------------------------------------- +# Step 0: Wipe existing builds +# --------------------------------------------------------------------------- +echo "" +echo "[0/4] Wiping existing builds..." + +if [ -d "${VTK_SRC}" ]; then + echo " Removing ${VTK_SRC} ..." + rm -rf "${VTK_SRC}" +fi + +if [ -d "${WRAP_BUILD}" ]; then + echo " Removing ${WRAP_BUILD} ..." + rm -rf "${WRAP_BUILD}" +fi + +echo " Done." + +# --------------------------------------------------------------------------- +# Step 1: Clone VTK at the exact version tag +# --------------------------------------------------------------------------- +echo "" +echo "[1/4] Cloning VTK ${VTK_TAG} into ${VTK_SRC} ..." + +git clone \ + https://github.com/Kitware/VTK.git \ + --branch "${VTK_TAG}" \ + --depth 1 \ + "${VTK_SRC}" + +echo " Clone complete." + +# --------------------------------------------------------------------------- +# Step 2: Build VTK from source +# --------------------------------------------------------------------------- +echo "" +echo "[2/4] Building VTK (this takes 15-30 minutes) ..." + +mkdir -p "${VTK_BUILD}" + +# Module disable notes: +# - VTK_WRAP_PYTHON=ON is required for the wrapping tools (vtkWrapHierarchy etc.) +# that WrapVTK depends on to generate XML, but it also enables Python wrapper +# compilation for every built module — so we disable all module groups we don't +# need to avoid compiling broken or unnecessary code. +# - IOImage and IOImage are in the StandAlone group alongside Common modules, +# so they cannot be excluded via group flags. DONT_WANT is overridden by the +# group DEFAULT, so NO is required — it is unconditional and ignores group +# membership. vtkSEPReader.cxx in IOImage fails to compile on GCC with +# VTK <= 9.1 (out-of-sync header/impl: missing EndiannessType, DataFormat +# members and std::int32_t). Safe to hard-disable: vtk-gen only reads +# vtkCommon* XML. +# - libproj (ThirdParty): bundled PROJ library uses std::int64_t without +# including ; fails on GCC >= 13. Pulled in by IO/GeoJSON and +# similar StandAlone modules we don't need. +cmake -S "${VTK_SRC}" -B "${VTK_BUILD}" \ + -DVTK_WRAP_PYTHON=ON \ + -DVTK_WRAP_JAVA=OFF \ + -DBUILD_TESTING=OFF \ + -DBUILD_SHARED_LIBS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DVTK_MODULE_ENABLE_VTK_CommonArchive=DONT_WANT \ + -DVTK_MODULE_ENABLE_VTK_CommonPython=DONT_WANT \ + -DVTK_MODULE_ENABLE_VTK_IOImage=NO \ + -DVTK_MODULE_ENABLE_VTK_libproj=NO \ + -DVTK_GROUP_ENABLE_Rendering=DONT_WANT \ + -DVTK_GROUP_ENABLE_Qt=DONT_WANT \ + -DVTK_GROUP_ENABLE_Web=DONT_WANT \ + -DVTK_GROUP_ENABLE_Views=DONT_WANT \ + -DVTK_GROUP_ENABLE_MPI=DONT_WANT \ + -DVTK_GROUP_ENABLE_Imaging=DONT_WANT + +cmake --build "${VTK_BUILD}" -j"${JOBS}" + +echo " VTK build complete." + +# Sanity check: ensure wrapping headers are present +if [ ! -f "${VTK_BUILD}/Wrapping/Tools/vtkParseAttributes.h" ] && \ + [ ! -f "${VTK_SRC}/Wrapping/Tools/vtkParseAttributes.h" ]; then + echo "" + echo "WARNING: vtkParseAttributes.h not found." + echo " WrapVTK may fail if wrapping headers are missing." +fi + +# --------------------------------------------------------------------------- +# Step 3: Build WrapVTK +# --------------------------------------------------------------------------- +echo "" +echo "[3/4] Building WrapVTK ..." + +# Initialise the submodule if it hasn't been cloned yet +if [ ! -f "${WRAP_VTK_DIR}/CMakeLists.txt" ]; then + echo " WrapVTK submodule not initialised — running git submodule update ..." + git -C "${SCRIPT_DIR}" submodule update --init --recursive +fi + +mkdir -p "${WRAP_BUILD}" +cmake -S "${WRAP_VTK_DIR}" -B "${WRAP_BUILD}" \ + -DVTK_DIR="${VTK_BUILD}" + +cmake --build "${WRAP_BUILD}" -j"${JOBS}" + +echo " WrapVTK build complete." + +# --------------------------------------------------------------------------- +# Step 4: Verify XML output +# --------------------------------------------------------------------------- +echo "" +echo "[4/4] Verifying XML output ..." + +XML_DIR="${WRAP_BUILD}/xml" + +if [ ! -d "${XML_DIR}" ]; then + echo "ERROR: XML directory not found at ${XML_DIR}" + echo " Something went wrong during the WrapVTK build." + exit 1 +fi + +XML_COUNT="$(ls -1 "${XML_DIR}" | wc -l)" +echo " Found ${XML_COUNT} XML module directories in ${XML_DIR}." + +if [ "${XML_COUNT}" -eq 0 ]; then + echo "ERROR: No XML files were generated. Check the WrapVTK build output." + exit 1 +fi + +echo "" +echo "==========================================" +echo " Setup complete for VTK ${VTK_TAG}!" +echo "" +echo " VTK build : ${VTK_BUILD}" +echo " XML output: ${XML_DIR}" +echo "" +echo " Next step — regenerate Rust bindings:" +echo " cargo run -p vtk-gen -- \\" +echo " --opath vtk-rs-${VTK_VERSION%.*} \\" +echo " --wrap-vtk WrapVTK" +echo "==========================================" diff --git a/vtk-gen/Cargo.toml b/vtk-gen/Cargo.toml index a0dceaa..31fd0bd 100644 --- a/vtk-gen/Cargo.toml +++ b/vtk-gen/Cargo.toml @@ -11,7 +11,7 @@ include = ["src/*.rs", "/Default/*"] anyhow = "1.0.98" cargo_toml = "0.22.3" clap = { version = "4.5.54", features = ["derive"] } -convert_case = "0.10.0" +convert_case = "0.11.0" glob = "0.3.2" log = "0.4.27" pretty_env_logger = "0.5.0" @@ -23,4 +23,4 @@ regex = "1.11.1" serde = { version = "1.0.219", features = ["derive"] } serde-xml-rs = "0.8.1" syn = "2.0.101" -toml = "0.9.11" +toml = "1.1.2" diff --git a/vtk-gen/src/code_gen_cpp.rs b/vtk-gen/src/code_gen_cpp.rs index 3c2b906..58ae719 100644 --- a/vtk-gen/src/code_gen_cpp.rs +++ b/vtk-gen/src/code_gen_cpp.rs @@ -74,6 +74,7 @@ impl FormatCppStr for IRType { c_ulong => Ok("unsigned long"), c_ulonglong => Ok("unsigned long long"), c_char => Ok("char"), + c_signed_char => Ok("signed char"), c_short => Ok("short"), c_int => Ok("int"), c_long => Ok("long"), @@ -88,6 +89,75 @@ impl FormatCppStr for IRType { } } +fn is_numeric_primitive(ty: &IRType) -> bool { + use IRType::*; + // c_char is excluded: char* is a C string, not an array. + // c_signed_char IS included: signed char* is a typed data buffer (e.g. vtkSignedCharArray), + // and char* ↔ signed char* is an error in C++ so we must not emit a pointer to it. + matches!( + ty, + c_signed_char + | c_uchar + | c_short + | c_ushort + | c_int + | c_uint + | c_long + | c_ulong + | c_longlong + | c_ulonglong + | float + | double + | usize + | bool + ) +} + +fn ir_type_to_cpp_string(irtype: &IRType) -> Result { + use IRType::*; + match irtype { + Unit => Ok("void".to_string()), + c_uchar => Ok("unsigned char".to_string()), + c_ushort => Ok("unsigned short".to_string()), + c_uint => Ok("unsigned int".to_string()), + c_ulong => Ok("unsigned long".to_string()), + c_ulonglong => Ok("unsigned long long".to_string()), + c_char => Ok("char".to_string()), + c_signed_char => Ok("signed char".to_string()), + c_short => Ok("short".to_string()), + c_int => Ok("int".to_string()), + c_long => Ok("long".to_string()), + c_longlong => Ok("long long".to_string()), + bool => Ok("bool".to_string()), + float => Ok("float".to_string()), + double => Ok("double".to_string()), + usize => Ok("size_t".to_string()), + String => Ok("const char*".to_string()), + Const(inner) => match inner.as_ref() { + String => Ok("const char*".to_string()), + other => Ok(format!("const {}", ir_type_to_cpp_string(other)?)), + }, + Pointer(inner) => { + // Strip one layer of Const to check the core element type + let core = match inner.as_ref() { + Const(x) => x.as_ref(), + x => x, + }; + if is_numeric_primitive(core) { + anyhow::bail!("pointer-to-numeric-primitive (array arg) not bridgeable") + } + // Mutable char* is not bridgeable: VTK may expect signed char* (data arrays), + // and C++ rejects implicit conversion between char* and signed char*. + if matches!(inner.as_ref(), c_char) { + anyhow::bail!("mutable char* not bridgeable (may conflict with signed char*)") + } + Ok(format!("{}*", ir_type_to_cpp_string(inner)?)) + } + Ref(inner) => Ok(format!("{}&", ir_type_to_cpp_string(inner)?)), + _ => anyhow::bail!("C++ type not supported: skipping method"), + } +} + impl IRModule { fn write_includes(&self, writer: &mut impl std::io::Write) -> Result<()> { writeln!(writer, "// Default include in all modules")?; @@ -110,20 +180,18 @@ impl IRModule { writeln!(writer)?; writeln!(writer, "// Implement declared functions")?; - // Include vtk libraries required - for (_, ir_struct) in self.classes.iter() { - if ir_struct.is_constructable() { - ir_struct.build_constructor(writer)?; - } - /* for method in ir_struct.exposable_methods.iter() { - match ir_struct.method_to_cpp(method, writer) { - Ok(_) => (), - Err(e) => log::warn!( + for (_, irstruct) in self.classes.iter() { + if irstruct.is_constructable() { + irstruct.build_constructor(writer)?; + for method in irstruct.exposable_methods.iter() { + if let Err(e) = irstruct.method_to_cpp(method, writer) { + log::warn!( "[Cpp] skipping method \"{}\" due to error: \"{e}\"", method.name - ), + ); + } } - }*/ + } } Ok(()) } @@ -133,9 +201,17 @@ impl IRModule { writeln!(writer)?; writeln!(writer, "// Declare exported functions")?; - for (_, ir_struct) in self.classes.iter() { - if ir_struct.is_constructable() { - ir_struct.build_constructor_headers(writer)?; + for (_, irstruct) in self.classes.iter() { + if irstruct.is_constructable() { + irstruct.build_constructor_headers(writer)?; + for method in irstruct.exposable_methods.iter() { + if let Err(e) = irstruct.method_to_cpp_header(method, writer) { + log::warn!( + "[Cpp] skipping method header \"{}\" due to: \"{e}\"", + method.name + ); + } + } } } Ok(()) @@ -155,90 +231,87 @@ impl IRModule { impl IRStruct { fn method_to_cpp(&self, method: &IRMethod, writer: &mut impl std::io::Write) -> Result<()> { - let mut params = String::new(); - for (n, (ident, ty)) in method.args.iter().enumerate() { - params.push_str(ty.to_cpp_str()?.as_ref()); - params.push(' '); - params.push_str(&ident.0); - if n + 1 < method.args.len() { - params.push_str(", "); - } + if matches!(method.return_type, IRType::String) { + anyhow::bail!("std::string return type cannot be bridged to const char*"); + } + let ret_str = ir_type_to_cpp_string(&method.return_type)?; + let is_void = matches!(method.return_type, IRType::Unit); + + let mut param_strs: Vec = vec![format!("{}* sself", self.name)]; + let mut call_args: Vec = vec![]; + for (ident, irtype) in &method.args { + param_strs.push(format!("{} {}", ir_type_to_cpp_string(irtype)?, ident.0)); + call_args.push(ident.0.clone()); } - let ty = &self.name; - let spointer = if params.is_empty() { - cpp!(vtkNew<#ty> self)? + let params = param_strs.join(", "); + let args = call_args.join(", "); + let body = if is_void { + format!("sself->{}({});", method.vtk_name, args) } else { - cpp!(vtkNew<#ty> self)? + format!("return sself->{}({});", method.vtk_name, args) }; - let ret = &method.return_type; - let vtk_name = &method.name; - let binding = format!("{}_{}", self.name, method.name); - let method = cpp!(#ret #binding (#spointer, #(#params),*) { - return self->#vtk_name(#(params),*); - })?; - writeln!(writer, "{}", method)?; + writeln!( + writer, + "extern \"C\" {} {}({}) {{ {} }}", + ret_str, method.name, params, body + )?; + Ok(()) + } + fn method_to_cpp_header( + &self, + method: &IRMethod, + writer: &mut impl std::io::Write, + ) -> Result<()> { + if matches!(method.return_type, IRType::String) { + anyhow::bail!("std::string return type cannot be bridged to const char*"); + } + let ret_str = ir_type_to_cpp_string(&method.return_type)?; + let mut param_strs: Vec = vec![format!("{}* sself", self.name)]; + for (ident, irtype) in &method.args { + param_strs.push(format!("{} {}", ir_type_to_cpp_string(irtype)?, ident.0)); + } + let params = param_strs.join(", "); + writeln!( + writer, + "extern \"C\" {} {}({});", + ret_str, method.name, params + )?; Ok(()) } fn build_constructor(&self, writer: &mut impl std::io::Write) -> Result<()> { let ty = &self.name; let constructor = self.constructor_binding_name(); - let func1 = cpp!(extern "C" vtkNew<#ty> #constructor() {return vtkNew<#ty>();})?; + let func1 = cpp!(extern "C" #ty* #constructor() {return #ty::New();})?; let destructor = self.destructor_binding_name(); - let func2 = cpp!(extern "C" void #destructor(vtkNew<#ty> sself) { - sself.Reset(); + let func2 = cpp!(extern "C" void #destructor(#ty* sself) { + sself->Delete(); return; })?; - let get_ptr = self.get_ptr_binding_name(); - let func3 = cpp!(extern "C" void* #get_ptr(vtkNew<#ty> sself) { - return sself.GetPointer(); - })?; - writeln!(writer, "{func1}")?; writeln!(writer, "{func2}")?; - writeln!(writer, "{func3}")?; Ok(()) } fn build_constructor_headers(&self, writer: &mut impl std::io::Write) -> Result<()> { let ty = &self.name; let constructor = self.constructor_binding_name(); - let func1 = cpp!(extern "C" vtkNew<#ty> #constructor();)?; + let func1 = cpp!(extern "C" #ty* #constructor();)?; let destructor = self.destructor_binding_name(); - let func2 = cpp!(extern "C" void #destructor(vtkNew<#ty> sself);)?; - - let get_ptr = self.get_ptr_binding_name(); - let func3 = cpp!(extern "C" void* #get_ptr(vtkNew<#ty> sself);)?; + let func2 = cpp!(extern "C" void #destructor(#ty* sself);)?; writeln!(writer, "{func1}")?; writeln!(writer, "{func2}")?; - writeln!(writer, "{func3}")?; Ok(()) } } -#[test] -fn test_cpp_macro() { - let out = cpp!(extern "C" void use_this(void* ptr) {return;}).unwrap(); - assert_eq!(out, "extern \"C\" void use_this (void * ptr) {return ;}"); -} - -#[test] -fn test_cpp_macro_repitition() { - let args = vec!["int indent", "char* stream", "bool flag"]; - let out = cpp!(void do_stuff(#(#args,)*) { return; }).unwrap(); - assert_eq!( - out, - "void do_stuff (int indent, char* stream, bool flag) {return ;}" - ); -} - /* impl FormatCpp for Option { fn to_cpp(&self, writer: &mut impl core::fmt::Write) -> Result<()> { match self { @@ -326,3 +399,109 @@ impl FormatCpp for IRMethod { Ok(()) } }*/ + +#[cfg(test)] +mod gen_cpp_tests { + use super::*; + use crate::intermediate_representation::{IRIdent, IRMethod, IRStruct}; + + #[test] + fn test_cpp_macro() { + let out = cpp!(extern "C" void use_this(void* ptr) {return;}).unwrap(); + assert_eq!(out, "extern \"C\" void use_this (void * ptr) {return ;}"); + } + + #[test] + fn test_cpp_macro_repetition() { + let args = vec!["int indent", "char* stream", "bool flag"]; + let out = cpp!(void do_stuff(#(#args,)*) { return; }).unwrap(); + assert_eq!( + out, + "void do_stuff (int indent, char* stream, bool flag) {return ;}" + ); + } + + #[test] + fn test_cpp_type_primitives() { + assert_eq!(ir_type_to_cpp_string(&IRType::Unit).unwrap(), "void"); + assert_eq!(ir_type_to_cpp_string(&IRType::c_int).unwrap(), "int"); + assert_eq!(ir_type_to_cpp_string(&IRType::double).unwrap(), "double"); + assert_eq!(ir_type_to_cpp_string(&IRType::bool).unwrap(), "bool"); + assert_eq!(ir_type_to_cpp_string(&IRType::float).unwrap(), "float"); + assert_eq!(ir_type_to_cpp_string(&IRType::usize).unwrap(), "size_t"); + } + + #[test] + fn test_cpp_type_string_maps_to_const_char_ptr() { + assert_eq!( + ir_type_to_cpp_string(&IRType::String).unwrap(), + "const char*" + ); + } + + #[test] + fn test_cpp_type_const_string_maps_to_const_char_ptr() { + assert_eq!( + ir_type_to_cpp_string(&IRType::Const(Box::new(IRType::String))).unwrap(), + "const char*" + ); + } + + #[test] + fn test_cpp_type_pointer_wraps_inner() { + assert_eq!( + ir_type_to_cpp_string(&IRType::Pointer(Box::new(IRType::Unit))).unwrap(), + "void*" + ); + } + + #[test] + fn test_cpp_type_unsupported_returns_error() { + assert!(ir_type_to_cpp_string(&IRType::FileMode).is_err()); + } + + fn make_struct(name: &str) -> IRStruct { + IRStruct::test_new(name, vec!["vtkObjectBase"], vec![]) + } + + #[test] + fn test_method_to_cpp_void_no_args() { + let s = make_struct("vtkFoo"); + let m = IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![]); + let mut out = Vec::new(); + s.method_to_cpp(&m, &mut out).unwrap(); + let src = String::from_utf8(out).unwrap(); + assert!(src.contains("extern \"C\" void vtk_foo_update")); + assert!(src.contains("vtkFoo* sself")); + assert!(src.contains("sself->Update()")); + } + + #[test] + fn test_method_to_cpp_with_args_and_return() { + let s = make_struct("vtkFoo"); + let m = IRMethod::test_new( + "vtk_foo_set_radius", + "SetRadius", + IRType::double, + vec![(IRIdent("r".to_string()), IRType::double)], + ); + let mut out = Vec::new(); + s.method_to_cpp(&m, &mut out).unwrap(); + let src = String::from_utf8(out).unwrap(); + assert!(src.contains("extern \"C\" double vtk_foo_set_radius")); + assert!(src.contains("double r")); + assert!(src.contains("return sself->SetRadius(r)")); + } + + #[test] + fn test_method_to_cpp_header_declaration() { + let s = make_struct("vtkFoo"); + let m = IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![]); + let mut out = Vec::new(); + s.method_to_cpp_header(&m, &mut out).unwrap(); + let src = String::from_utf8(out).unwrap(); + assert!(src.contains("extern \"C\" void vtk_foo_update")); + assert!(src.ends_with(";\n")); + assert!(!src.contains("sself->"), "header must not contain body"); + } +} \ No newline at end of file diff --git a/vtk-gen/src/code_gen_rust.rs b/vtk-gen/src/code_gen_rust.rs index 7e1e77a..3c42e01 100644 --- a/vtk-gen/src/code_gen_rust.rs +++ b/vtk-gen/src/code_gen_rust.rs @@ -3,7 +3,221 @@ use quote::ToTokens; use crate::intermediate_representation::IRIdent; -// use crate::parse_cpp::StdFunction; + +fn is_rust_keyword(s: &str) -> bool { + matches!( + s, + "as" + | "async" + | "await" + | "become" + | "box" + | "break" + | "const" + | "continue" + | "crate" + | "do" + | "dyn" + | "else" + | "enum" + | "extern" + | "false" + | "final" + | "fn" + | "for" + | "if" + | "impl" + | "in" + | "let" + | "loop" + | "macro" + | "match" + | "mod" + | "move" + | "mut" + | "override" + | "priv" + | "pub" + | "ref" + | "return" + | "self" + | "Self" + | "static" + | "struct" + | "super" + | "trait" + | "true" + | "try" + | "type" + | "typeof" + | "unsafe" + | "unsized" + | "use" + | "virtual" + | "where" + | "while" + | "yield" + ) +} + +/// Returns false for IRType variants that have no Rust representation yet. +/// Methods containing unsupported types are skipped before code gen. +fn ir_type_is_supported(irtype: &crate::IRType) -> bool { + use crate::IRType::*; + match irtype { + // Path types (VTK object names) are only bridgeable as opaque pointers. + // Passing VTK objects by value or reference (e.g. `const vtkStdString&`) is not bridgeable. + FileMode | File | Path(_) => false, + Pointer(inner) => { + // Mutable char* (Pointer(c_char)) is not safely bridgeable: it may be a signed + // char data buffer rather than a C string, causing char*/signed char* type errors. + // Only Pointer(Const(c_char)) (= const char*, C string) and VTK object pointers are ok. + if matches!(inner.as_ref(), c_char) { + return false; + } + is_string_type(irtype) || matches!(inner.as_ref(), Path(_)) + } + // Heap-allocated collection types cannot cross the FFI boundary safely. + Vec(_) | LinkedList(_) | Map(_, _) => false, + Ref(inner) | Const(inner) => ir_type_is_supported(inner), + Array(inner, _) => ir_type_is_supported(inner), + _ => true, + } +} + +fn method_is_supported(method: &crate::IRMethod) -> bool { + // std::string return types can't be bridged: the C++ callee returns by value and the + // resulting const char* would dangle immediately. String *parameters* are fine. + !matches!(method.return_type, crate::IRType::String) + && ir_type_is_supported(&method.return_type) + && method.args.iter().all(|(_, irtype)| ir_type_is_supported(irtype)) +} + +/// Returns a safe Rust identifier by appending an underscore if the given string is a Rust keyword. +fn safe_ident(s: &str) -> String { + if is_rust_keyword(s) { + format!("{}_", s) + } else { + s.to_string() + } +} + +fn capitalize_first(s: &str) -> String { + let mut chars = s.chars(); + match chars.next() { + None => String::new(), + Some(c) => c.to_uppercase().collect::() + chars.as_str(), + } +} + +fn is_string_type(irtype: &crate::IRType) -> bool { + use crate::IRType::*; + match irtype { + String | c_char => true, + Const(inner) | Ref(inner) | Pointer(inner) => is_string_type(inner), + _ => false, + } +} + +/// Rust type used in the trait method signature (user-facing). +fn ir_type_as_param_sig(irtype: &crate::IRType) -> TokenStream { + if is_string_type(irtype) { + return quote::quote!(&str); + } + match irtype { + // VTK object pointers are always passed as opaque c_void pointers across the C bridge. + crate::IRType::Path(_) => quote::quote!(*mut core::ffi::c_void), + crate::IRType::Pointer(inner) if matches!(inner.as_ref(), crate::IRType::Path(_)) => { + quote::quote!(*mut core::ffi::c_void) + } + _ => quote::quote!(#irtype), + } +} + +/// Rust type used in the extern "C" declaration inside an impl body. +fn ir_type_as_c_extern(irtype: &crate::IRType) -> TokenStream { + match irtype { + crate::IRType::String => quote::quote!(*const core::ffi::c_char), + crate::IRType::Const(inner) if matches!(inner.as_ref(), crate::IRType::String) => { + quote::quote!(*const core::ffi::c_char) + } + crate::IRType::Path(_) => quote::quote!(*mut core::ffi::c_void), + crate::IRType::Pointer(inner) if matches!(inner.as_ref(), crate::IRType::Path(_)) => { + quote::quote!(*mut core::ffi::c_void) + } + other => quote::quote!(#other), + } +} + +fn build_method_impl(class_name: &str, method: &crate::IRMethod) -> TokenStream { + use quote::quote; + + let short = safe_ident(&method.short_name(class_name)); + let method_ident = quote::format_ident!("{}", short); + let full_name_ident = quote::format_ident!("{}", &method.name); + + let ret_sig = ir_type_as_param_sig(&method.return_type); + let ret_c = ir_type_as_c_extern(&method.return_type); + let is_string_ret = is_string_type(&method.return_type); + let is_void_ret = matches!(&method.return_type, crate::IRType::Unit); + + let mut pre_call: Vec = vec![]; + let mut extern_args: Vec = vec![quote!(sself: *mut core::ffi::c_void)]; + let mut trait_params: Vec = vec![]; + let mut call_args: Vec = vec![quote!(self.0)]; + + for (name, irtype) in &method.args { + let param_ty = ir_type_as_param_sig(irtype); + trait_params.push(quote!(#name: #param_ty)); + + if is_string_type(irtype) { + let c_name = quote::format_ident!("c_{}", name.0); + pre_call.push(quote!( + let #c_name = std::ffi::CString::new(#name).expect("CString::new failed"); + )); + extern_args.push(quote!(#name: *const core::ffi::c_char)); + call_args.push(quote!(#c_name.as_ptr())); + } else { + let c_type = ir_type_as_c_extern(irtype); + extern_args.push(quote!(#name: #c_type)); + call_args.push(quote!(#name)); + } + } + + let body = if is_string_ret { + quote!( + #(#pre_call)* + unsafe extern "C" { + fn #full_name_ident(#(#extern_args),*) -> *const core::ffi::c_char; + } + let ptr = unsafe { #full_name_ident(#(#call_args),*) }; + if ptr.is_null() { return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + ) + } else if is_void_ret { + quote!( + #(#pre_call)* + unsafe extern "C" { + fn #full_name_ident(#(#extern_args),*); + } + unsafe { #full_name_ident(#(#call_args),*) } + ) + } else { + quote!( + #(#pre_call)* + unsafe extern "C" { + fn #full_name_ident(#(#extern_args),*) -> #ret_c; + } + unsafe { #full_name_ident(#(#call_args),*) } + ) + }; + + quote!( + fn #method_ident(&mut self, #(#trait_params),*) -> #ret_sig { + #body + } + ) +} impl ToTokens for crate::IRType { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { @@ -17,10 +231,11 @@ impl ToTokens for crate::IRType { let ty = match self { Unit => quote::quote!(()), c_char => quote!(core::ffi::c_char), + c_signed_char => quote!(core::ffi::c_schar), c_short => quote!(core::ffi::c_short), c_int => quote!(core::ffi::c_int), c_long => quote!(core::ffi::c_long), - c_longlong => quote!(core::ffi::c_uchar), + c_longlong => quote!(core::ffi::c_longlong), c_uchar => quote!(core::ffi::c_uchar), c_ushort => quote!(core::ffi::c_ushort), c_uint => quote!(core::ffi::c_uint), @@ -66,7 +281,12 @@ impl ToTokens for crate::IRType { impl ToTokens for IRIdent { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { - let id = quote::format_ident!("{}", self.0); + let name = if is_rust_keyword(&self.0) { + format!("{}_", self.0) + } else { + self.0.clone() + }; + let id = quote::format_ident!("{}", name); tokens.extend(quote::quote!(#id)) } } @@ -77,6 +297,7 @@ impl ToTokens for crate::IRMethod { name, return_type, args, + .. } = &self; let name = quote::format_ident!("{name}"); @@ -89,11 +310,79 @@ impl ToTokens for crate::IRMethod { impl crate::IRModule { fn identify_traits(&self) -> TokenStream { - TokenStream::new() + let mut output = TokenStream::new(); + for (class_name, ir_struct) in &self.classes { + if ir_struct.exposable_methods.is_empty() { + continue; + } + let trait_ident = quote::format_ident!("{}", capitalize_first(class_name)); + + // Supertrait bounds would require implementing every ancestor trait for each + // concrete struct across module boundaries, which the generator doesn't yet support. + let parent_bounds: Vec = vec![]; + + let method_sigs: Vec = ir_struct + .exposable_methods + .iter() + .filter(|m| method_is_supported(m)) + .map(|method| { + let short = safe_ident(&method.short_name(class_name)); + let method_ident = quote::format_ident!("{}", short); + let args: Vec = method + .args + .iter() + .map(|(name, irtype)| { + let sig_ty = ir_type_as_param_sig(irtype); + quote::quote!(#name: #sig_ty) + }) + .collect(); + let ret = ir_type_as_param_sig(&method.return_type); + quote::quote!(fn #method_ident(&mut self, #(#args),*) -> #ret;) + }) + .collect(); + + let trait_def = if parent_bounds.is_empty() { + quote::quote!( + pub trait #trait_ident { + #(#method_sigs)* + } + ) + } else { + quote::quote!( + pub trait #trait_ident: #(#parent_bounds)+* { + #(#method_sigs)* + } + ) + }; + + output.extend(trait_def); + } + output } fn implement_own_traits(&self) -> TokenStream { - TokenStream::new() + let mut output = TokenStream::new(); + for (class_name, ir_struct) in &self.classes { + if !ir_struct.is_constructable() || ir_struct.exposable_methods.is_empty() { + continue; + } + let struct_ident = quote::format_ident!("{}", class_name); + let trait_ident = quote::format_ident!("{}", capitalize_first(class_name)); + + let methods: Vec = ir_struct + .exposable_methods + .iter() + .filter(|m| method_is_supported(m)) + .map(|method| build_method_impl(class_name, method)) + .collect(); + + output.extend(quote::quote!( + impl #trait_ident for #struct_ident { + #(#methods)* + } + )); + } + output } fn create_bindings(&self) -> TokenStream { @@ -125,9 +414,8 @@ impl crate::IRModule { }); let constructor = quote::format_ident!("{}", c.constructor_binding_name()); - let constructor_comment = format!(" Creates a new [{name}] wrapped inside `vtkNew`"); + let constructor_comment = format!(" Creates a new [{name}] via `{struct_name}::New()`"); let destructor = quote::format_ident!("{}", c.destructor_binding_name()); - let get_ptr = quote::format_ident!("{}", c.get_ptr_binding_name()); let testname = quote::format_ident!("test_{}_create_drop", c.name); @@ -145,16 +433,7 @@ impl crate::IRModule { unsafe extern "C" { fn #constructor() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *#constructor() }) - } - - // This method is supposed to be used for testing only - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn #get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { #get_ptr( self.0 ) } + Self(unsafe { #constructor() }) } } @@ -175,21 +454,10 @@ impl crate::IRModule { } #[test] - fn #testname () { - // Create a new heap-allocated object behind vtkNew<..> - let obj = #name :: new(); - // Store the internal pointer which now contains the vtkNew<..> pointer - let ptr = obj.0; - // Ensure that the vtkNew<..> pointer and its content are not null - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); - // Manually drop the object, freeing the memory and nulling the pointer + fn #testname() { + let obj = #name::new(); + assert!(!obj.0.is_null()); drop(obj); - // Wrap the previous pointer in new object without explicitly calling - // constructor. This allows us to access its contents with the defined API. - let new_obj = #name(ptr); - // Ensure that the previously created object is null - assert!(unsafe { new_obj._get_ptr().is_null() }); } )); } @@ -200,43 +468,14 @@ impl crate::IRModule { impl quote::ToTokens for crate::IRModule { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { - let modname = syn::Ident::new(&self.name, proc_macro2::Span::call_site()); - - // Identify traits as exposable methods of parent classes and provide default - // implementations. let traits = self.identify_traits(); tokens.extend(quote::quote!(#traits)); - // Implement traits for classes exposed in this module. let implement_self = self.implement_own_traits(); tokens.extend(quote::quote!(#implement_self)); - // Implement existing traits from other modules for classes exposed in this module - let bindings = self.create_bindings(); - - let mut output = quote::quote!(); - for class in self.classes.values() { - if class.is_constructable() { - let mut methods = quote::quote!(); - for method in class.exposable_methods.iter().take(2) { - methods.extend(quote::quote!(#method)); - } - let class_name = syn::Ident::new(&class.name, proc_macro2::Span::call_site()); - output.extend(quote::quote!( - impl #class_name { - #methods - } - )); - } - } - tokens.extend(quote::quote!( - // #[allow(non_camel_case_types)] - // pub mod #modname { - // #output - // } - #bindings - )); + tokens.extend(bindings); } } @@ -254,3 +493,186 @@ impl quote::ToTokens for crate::parse_cpp::Path { tokens.extend(r); } } + +#[cfg(test)] +mod gen_rust_tests { + use super::*; + use crate::intermediate_representation::{IRIdent, IRMethod, IRModule, IRStruct, IRType}; + use std::collections::BTreeMap; + + fn make_module(classes: BTreeMap) -> IRModule { + IRModule { + name: "TestModule".to_string(), + classes, + } + } + + #[test] + fn test_is_rust_keyword_true_for_keywords() { + for kw in &["type", "self", "break", "fn", "impl", "trait", "use", "ref", "unsafe"] { + assert!(is_rust_keyword(kw), "{kw} should be a keyword"); + } + } + + #[test] + fn test_is_rust_keyword_false_for_non_keywords() { + for word in &["radius", "vtkFoo", "set_value", "get_output", ""] { + assert!(!is_rust_keyword(word), "{word} should not be a keyword"); + } + } + + #[test] + fn test_safe_ident_appends_underscore_for_keywords() { + assert_eq!(safe_ident("type"), "type_"); + assert_eq!(safe_ident("self"), "self_"); + assert_eq!(safe_ident("break"), "break_"); + assert_eq!(safe_ident("ref"), "ref_"); + } + + #[test] + fn test_safe_ident_unchanged_for_non_keywords() { + assert_eq!(safe_ident("radius"), "radius"); + assert_eq!(safe_ident("get_output"), "get_output"); + } + + #[test] + fn test_capitalize_first_vtk_class() { + assert_eq!(capitalize_first("vtkFoo"), "VtkFoo"); + assert_eq!(capitalize_first("vtkObjectBase"), "VtkObjectBase"); + } + + #[test] + fn test_capitalize_first_edge_cases() { + assert_eq!(capitalize_first(""), ""); + assert_eq!(capitalize_first("a"), "A"); + } + + #[test] + fn test_ir_type_is_supported_rejects_filemode() { + assert!(!ir_type_is_supported(&IRType::FileMode)); + assert!(!ir_type_is_supported(&IRType::File)); + assert!(!ir_type_is_supported(&IRType::Pointer(Box::new(IRType::FileMode)))); + } + + #[test] + fn test_ir_type_is_supported_accepts_primitives() { + assert!(ir_type_is_supported(&IRType::c_int)); + assert!(ir_type_is_supported(&IRType::double)); + assert!(ir_type_is_supported(&IRType::bool)); + assert!(ir_type_is_supported(&IRType::String)); + assert!(ir_type_is_supported(&IRType::Unit)); + } + + #[test] + fn test_ir_ident_keyword_gets_underscore_suffix() { + let id = IRIdent("type".to_string()); + assert_eq!(quote::quote!(#id).to_string(), "type_"); + } + + #[test] + fn test_ir_ident_self_gets_underscore_suffix() { + let id = IRIdent("self".to_string()); + assert_eq!(quote::quote!(#id).to_string(), "self_"); + } + + #[test] + fn test_ir_ident_normal_name_unchanged() { + let id = IRIdent("radius".to_string()); + assert_eq!(quote::quote!(#id).to_string(), "radius"); + } + + #[test] + fn test_identify_traits_empty_module_produces_no_tokens() { + let module = make_module(BTreeMap::new()); + assert!(module.identify_traits().is_empty()); + } + + #[test] + fn test_identify_traits_skips_class_with_no_methods() { + let mut classes = BTreeMap::new(); + classes.insert( + "vtkFoo".to_string(), + IRStruct::test_new("vtkFoo", vec!["vtkObjectBase"], vec![]), + ); + let module = make_module(classes); + assert!(module.identify_traits().is_empty()); + } + + #[test] + fn test_identify_traits_generates_trait_for_class_with_methods() { + let mut classes = BTreeMap::new(); + classes.insert( + "vtkFoo".to_string(), + IRStruct::test_new( + "vtkFoo", + vec!["vtkObjectBase"], + vec![IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![])], + ), + ); + let module = make_module(classes); + let output = module.identify_traits().to_string(); + assert!(output.contains("VtkFoo"), "trait name VtkFoo missing"); + assert!(output.contains("update"), "method name update missing"); + } + + #[test] + fn test_identify_traits_keyword_method_name_gets_suffix() { + let mut classes = BTreeMap::new(); + classes.insert( + "vtkBreakPoint".to_string(), + IRStruct::test_new( + "vtkBreakPoint", + vec!["vtkObjectBase"], + vec![IRMethod::test_new( + "vtk_break_point_break", + "Break", + IRType::Unit, + vec![], + )], + ), + ); + let module = make_module(classes); + let output = module.identify_traits().to_string(); + assert!(output.contains("break_"), "keyword method should be renamed to break_"); + assert!(!output.contains(" break ("), "bare keyword 'break' must not appear as method name"); + } + + #[test] + fn test_implement_own_traits_skips_non_constructable() { + let mut classes = BTreeMap::new(); + // no "vtkObjectBase" parent -> not constructable + classes.insert( + "vtkAbstract".to_string(), + IRStruct::test_new( + "vtkAbstract", + vec![], + vec![IRMethod::test_new("vtk_abstract_run", "Run", IRType::Unit, vec![])], + ), + ); + let module = make_module(classes); + assert!(module.implement_own_traits().is_empty()); + } + + #[test] + fn test_implement_own_traits_generates_impl_for_constructable() { + let mut classes = BTreeMap::new(); + classes.insert( + "vtkFoo".to_string(), + IRStruct::test_new( + "vtkFoo", + vec!["vtkObjectBase"], + vec![IRMethod::test_new( + "vtk_foo_set_value", + "SetValue", + IRType::Unit, + vec![(IRIdent("v".to_string()), IRType::c_int)], + )], + ), + ); + let module = make_module(classes); + let output = module.implement_own_traits().to_string(); + assert!(output.contains("impl VtkFoo for vtkFoo")); + assert!(output.contains("vtk_foo_set_value")); + assert!(output.contains("set_value")); + } +} diff --git a/vtk-gen/src/inheritance_hierarchy.rs b/vtk-gen/src/inheritance_hierarchy.rs index 199bb87..458bca9 100644 --- a/vtk-gen/src/inheritance_hierarchy.rs +++ b/vtk-gen/src/inheritance_hierarchy.rs @@ -88,6 +88,26 @@ impl ClassHierarchy { .filter_map(|name| self.classes.get(name)) } + /// Returns true if `target` appears anywhere in the full ancestor chain of `class_name`. + pub fn has_ancestor(&self, class_name: &str, target: &str) -> bool { + let mut stack = vec![class_name.to_string()]; + let mut visited = std::collections::HashSet::new(); + while let Some(current) = stack.pop() { + if !visited.insert(current.clone()) { + continue; + } + if let Some((_, parents)) = self.tree.get(¤t) { + for parent in parents { + if parent == target { + return true; + } + stack.push(parent.clone()); + } + } + } + false + } + pub fn has_dependant(&self, class: &Class) -> bool { self.dependents .get(&class.name.clone()) @@ -120,7 +140,8 @@ impl ClassHierarchy { let parent_methods: Vec<_> = all_parents .into_iter() - .flat_map(|class_name| self.classes[&class_name].methods.public.iter()) + .filter_map(|class_name| self.classes.get(&class_name)) + .flat_map(|c| c.methods.public.iter()) .collect(); let unique_methods: Vec<_> = self.classes[class_name] @@ -131,8 +152,149 @@ impl ClassHierarchy { .filter(|x| !parent_methods.contains(&x)) .filter(|x| x.signature.trim().chars().take(8).collect::() != "template") .filter(|x| !x.signature.contains("typename")) + // C-style array parameters (e.g. `double pts[3]`) decay to pointers but WrapVTK + // records no pointer attribute for them. We can't bridge array parameters safely + // without explicit length info, so skip any method whose signature contains `[`. + .filter(|x| !x.signature.contains('[')) .collect(); Ok(unique_methods) } } + +#[cfg(test)] +mod inheritance_tests { + use super::*; + use crate::parse_wrap_vtk_xml::{ + Access, CContext, Class, Constructor, Destructor, File, Inheritance, Method, Methods, + Module, + }; + + fn make_method(name: &str) -> Method { + Method { + name: name.to_string(), + property: None, + access: Access::Public, + is_const: false, + is_static: false, + is_virtual: true, + signature: format!("void {}()", name), + parameters: vec![], + comment: None, + return_type: None, + } + } + + fn make_class(name: &str, parents: Vec<&str>, methods: Vec<&str>) -> Class { + Class { + name: name.to_string(), + is_abstract: false, + is_template: false, + comment: None, + base: vec![], + inheritance: if parents.is_empty() { + None + } else { + Some(Inheritance { + context: parents + .iter() + .map(|p| CContext { + name: p.to_string(), + access: Access::Public, + }) + .collect(), + }) + }, + methods: Methods { + public: methods.iter().map(|m| make_method(m)).collect(), + private: vec![], + protected: vec![], + }, + typedefs: vec![], + properties: vec![], + members: vec![], + constructors: vec![Constructor { + access: Access::Public, + signature: String::new(), + }], + destructors: vec![Destructor { + access: Access::Public, + signature: String::new(), + }], + } + } + + fn make_module(classes: Vec) -> Module { + Module { + name: "TestModule".to_string(), + path: std::path::PathBuf::new(), + files: vec![( + std::path::PathBuf::new(), + File { + name: "test.h".to_string(), + classes, + }, + )], + } + } + + #[test] + fn test_get_parent_names_direct_parent() { + let base = make_class("Base", vec![], vec!["BaseMethod"]); + let child = make_class("Child", vec!["Base"], vec!["ChildMethod"]); + let module = make_module(vec![base, child]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let parents: Vec<_> = hierarchy.get_parent_names("Child").into_iter().collect(); + assert_eq!(parents, vec!["Base"]); + } + + #[test] + fn test_get_parent_names_root_class_has_no_parents() { + let base = make_class("Base", vec![], vec!["BaseMethod"]); + let module = make_module(vec![base]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let parents: Vec<_> = hierarchy.get_parent_names("Base").into_iter().collect(); + assert!(parents.is_empty()); + } + + #[test] + fn test_get_exposable_methods_unique_to_child() { + let base = make_class("Base", vec![], vec!["SharedMethod"]); + let child = make_class("Child", vec!["Base"], vec!["SharedMethod", "ChildOnly"]); + let module = make_module(vec![base, child]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let methods = hierarchy.get_exposable_methods("Child").unwrap(); + let names: Vec<_> = methods.iter().map(|m| m.name.as_str()).collect(); + assert_eq!(names, vec!["ChildOnly"]); + } + + #[test] + fn test_get_exposable_methods_all_when_no_parent() { + let base = make_class("Base", vec![], vec!["Method1", "Method2"]); + let module = make_module(vec![base]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let methods = hierarchy.get_exposable_methods("Base").unwrap(); + assert_eq!(methods.len(), 2); + } + + #[test] + fn test_get_exposable_methods_filters_template_signatures() { + let mut class = make_class("Foo", vec![], vec![]); + class.methods.public.push(Method { + name: "TplMethod".to_string(), + signature: "template void TplMethod()".to_string(), + ..make_method("TplMethod") + }); + class.methods.public.push(make_method("NormalMethod")); + let module = make_module(vec![class]); + let hierarchy = ClassHierarchy::new(&[module]).unwrap(); + + let methods = hierarchy.get_exposable_methods("Foo").unwrap(); + let names: Vec<_> = methods.iter().map(|m| m.name.as_str()).collect(); + assert_eq!(names, vec!["NormalMethod"]); + } +} diff --git a/vtk-gen/src/intermediate_representation.rs b/vtk-gen/src/intermediate_representation.rs index 0e0daf2..37d8bd4 100644 --- a/vtk-gen/src/intermediate_representation.rs +++ b/vtk-gen/src/intermediate_representation.rs @@ -9,7 +9,10 @@ use crate::parse_wrap_vtk_xml::{Access, Module}; pub enum IRType { /// Type `()` or `void` in C++ Unit, + /// Plain C `char` (used for C strings / VTK_FILEPATH parameters) c_char, + /// Explicitly `signed char` (used for VTK typed-data arrays, e.g. vtkSignedCharArray) + c_signed_char, c_short, c_int, c_long, @@ -44,7 +47,8 @@ impl TryFrom<&CppType> for IRType { use IRType::*; let res = match value { Void => Unit, - SignedChar => c_char, + PlainChar => c_char, + SignedChar => c_signed_char, UnsignedChar => c_uchar, ShortInt => c_short, UnsignedShortInt => c_ushort, @@ -97,12 +101,26 @@ impl From for IRIdent { } pub struct IRMethod { + /// Full snake_case binding name, e.g. `vtk_sphere_source_set_radius` pub name: String, + /// Original PascalCase VTK method name, e.g. `SetRadius` (used in C++ call) + pub vtk_name: String, pub return_type: IRType, pub args: Vec<(IRIdent, IRType)>, } impl IRMethod { + /// Strip the class snake_case prefix to get the short method name. + /// e.g. `vtk_sphere_source_set_radius` → `set_radius` (for `vtkSphereSource`) + pub fn short_name(&self, class_name: &str) -> String { + use convert_case::Casing; + let prefix = format!("{}_", class_name.to_case(convert_case::Case::Snake)); + self.name + .strip_prefix(&prefix) + .unwrap_or(&self.name) + .to_string() + } + fn convert_from_class(class: &crate::Class, value: &crate::Method) -> Result { use crate::parse_cpp::Parse; let return_type = if let Some(crate::ReturnType { ret_type, pointer }) = &value.return_type @@ -112,7 +130,13 @@ impl IRMethod { Some(crate::Pointer::Ref) => CppType::Ref(Box::new(inner_ty)), Some(crate::Pointer::Star) => CppType::Pointer(Box::new(inner_ty)), Some(crate::Pointer::StarStar) => { - CppType::Pointer(Box::new(CppType::Ref(Box::new(inner_ty)))) + anyhow::bail!("double pointer not bridgeable") + } + Some(crate::Pointer::StarStarConst) => { + anyhow::bail!("const double pointer not bridgeable") + } + Some(crate::Pointer::StarStarStar) => { + anyhow::bail!("triple pointer not bridgeable") } None => inner_ty, } @@ -128,12 +152,28 @@ impl IRMethod { .map(|(n, param)| { let name = match ¶m.name { Some(name) => name.clone(), - // TODO make this better None => format!("p{n}"), }; let name = crate::parse_cpp::Ident::parse(&name)?; let name = IRIdent::from(name); - let cpp_ty = CppType::parse(¶m.r#type)?; + let inner_ty = CppType::parse(¶m.r#type)?; + // WrapVTK stores pointer/reference qualifiers separately from the type string, + // just like it does for return types. + let cpp_ty = match ¶m.pointer { + Some(crate::Pointer::Ref) => CppType::Ref(Box::new(inner_ty)), + Some(crate::Pointer::Star) => CppType::Pointer(Box::new(inner_ty)), + Some(crate::Pointer::StarStar) => { + anyhow::bail!("double pointer not bridgeable") + } + Some(crate::Pointer::StarStarConst) => { + anyhow::bail!("const double pointer not bridgeable") + } + Some(crate::Pointer::StarStarStar) => { + anyhow::bail!("triple pointer not bridgeable") + } + None if param.reference => CppType::Ref(Box::new(inner_ty)), + None => inner_ty, + }; Ok((name, IRType::try_from(&cpp_ty)?)) }) .collect::>>()?; @@ -141,6 +181,7 @@ impl IRMethod { use convert_case::*; Ok(IRMethod { name: format!("{}_{}", class.name, value.name).to_case(Case::Snake), + vtk_name: value.name.clone(), return_type, args, }) @@ -155,6 +196,8 @@ pub struct IRStruct { pub is_abstract: bool, pub is_template: bool, pub filename: String, + /// True when vtkObjectBase appears anywhere in the full ancestor chain (not just direct parents). + pub has_vtk_object_base_ancestor: bool, constructors: Vec, destructors: Vec, } @@ -168,10 +211,6 @@ impl IRStruct { format!("{}_destructor", self.name) } - pub fn get_ptr_binding_name(&self) -> String { - format!("{}_get_ptr", self.name) - } - pub(crate) fn is_constructable(&self) -> bool { self.constructors .iter() @@ -180,9 +219,8 @@ impl IRStruct { && !self.is_abstract && !self.is_template && !self.exposable_methods.is_empty() - // This could be lifted in the future when considering objects which can be constructed - // not via vtkNew<..>() - && self.parents.iter().any(|c| c == "vtkObjectBase") + // Only vtkObjectBase subclasses have the New() / Delete() reference-counting API. + && self.has_vtk_object_base_ancestor } } @@ -238,10 +276,27 @@ impl IRModule { } } }) + // C doesn't support overloading: drop duplicate binding names, + // keeping only the first overload seen for each name. + .scan(std::collections::HashSet::new(), |seen, m| { + if seen.insert(m.name.clone()) { + Some(Some(m)) + } else { + log::warn!( + "[IR] Skipping overloaded duplicate binding \"{}\" of class \"{}\"", + m.name, + class.name, + ); + Some(None) + } + }) + .flatten() .collect::>(), is_abstract: class.is_abstract, is_template: class.is_template, filename: filename.clone(), + has_vtk_object_base_ancestor: class_hierarchy + .has_ancestor(&class.name, "vtkObjectBase"), constructors: class.constructors, destructors: class.destructors, }, @@ -255,3 +310,105 @@ impl IRModule { }) } } + +// test helpers (available to all test modules in this crate) +#[cfg(test)] +impl IRMethod { + pub(crate) fn test_new( + name: &str, + vtk_name: &str, + return_type: IRType, + args: Vec<(IRIdent, IRType)>, + ) -> Self { + IRMethod { + name: name.to_string(), + vtk_name: vtk_name.to_string(), + return_type, + args, + } + } +} + +#[cfg(test)] +impl IRStruct { + pub(crate) fn test_new(name: &str, parents: Vec<&str>, methods: Vec) -> Self { + use crate::parse_wrap_vtk_xml::{Access, Constructor, Destructor}; + IRStruct { + name: name.to_string(), + description: vec![], + parents: parents.iter().map(|s| s.to_string()).collect(), + exposable_methods: methods, + is_abstract: false, + is_template: false, + filename: format!("{}.h", name), + has_vtk_object_base_ancestor: parents.contains(&"vtkObjectBase"), + constructors: vec![Constructor { + access: Access::Public, + signature: String::new(), + }], + destructors: vec![Destructor { + access: Access::Public, + signature: String::new(), + }], + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_short_name_strips_class_prefix() { + let m = IRMethod::test_new( + "vtk_sphere_source_set_radius", + "SetRadius", + IRType::Unit, + vec![], + ); + assert_eq!(m.short_name("vtkSphereSource"), "set_radius"); + } + + #[test] + fn test_short_name_multi_word_class() { + let m = IRMethod::test_new( + "vtk_object_base_get_class_name", + "GetClassName", + IRType::Unit, + vec![], + ); + assert_eq!(m.short_name("vtkObjectBase"), "get_class_name"); + } + + #[test] + fn test_short_name_no_matching_prefix_returns_full() { + let m = IRMethod::test_new("vtk_foo_bar", "FooBar", IRType::Unit, vec![]); + assert_eq!(m.short_name("vtkOther"), "vtk_foo_bar"); + } + + #[test] + fn test_is_constructable_happy_path() { + let s = IRStruct::test_new( + "vtkFoo", + vec!["vtkObjectBase"], + vec![IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![])], + ); + assert!(s.is_constructable()); + } + + #[test] + fn test_is_constructable_requires_objectbase_ancestor() { + let s = IRStruct::test_new( + "vtkFoo", + vec!["vtkOther"], + vec![IRMethod::test_new("vtk_foo_update", "Update", IRType::Unit, vec![])], + ); + assert!(!s.is_constructable()); + } + + #[test] + fn test_is_constructable_requires_methods() { + let s = IRStruct::test_new("vtkFoo", vec!["vtkObjectBase"], vec![]); + assert!(!s.is_constructable()); + } +} diff --git a/vtk-gen/src/main.rs b/vtk-gen/src/main.rs index 16d5268..e48f7ef 100644 --- a/vtk-gen/src/main.rs +++ b/vtk-gen/src/main.rs @@ -158,6 +158,40 @@ fn write_rust_main(modules: &[IRModule], writer: &mut impl std::io::Write) -> Re )); } + // Re-export all constructable classes at crate root, stripping the `vtk` prefix. + // e.g. `vtkSphereSource` → `SphereSource`, `vtkNamedColors` → `NamedColors`. + let mut prelude_uses = quote::quote!(); + for m in modules { + let mod_name = quote::format_ident!("{}", m.name); + for (class_name, class) in &m.classes { + if class.is_constructable() { + let alias_name = if class_name.starts_with("vtk") { + class_name[3..].to_string() + } else { + use convert_case::Casing; + class_name.to_case(convert_case::Case::Pascal) + }; + let class_ident = quote::format_ident!("{}", class_name); + let alias_ident = quote::format_ident!("{}", alias_name); + o1.extend(quote::quote!( + pub use #mod_name::#class_ident as #alias_ident; + )); + } + } + // Collect all pub trait re-exports for the prelude (crate:: prefix required in Rust 2018+) + prelude_uses.extend(quote::quote!( + pub use crate::#mod_name::*; + )); + } + + // Generate a prelude module that re-exports all traits via glob so users can write + // `use vtk_rs::prelude::*;` and call trait methods without explicit imports. + o1.extend(quote::quote!( + pub mod prelude { + #prelude_uses + } + )); + format_quote_and_write(o1, writer)?; Ok(()) } @@ -217,10 +251,10 @@ fn write_build_rs(writer: &mut impl std::io::Write, ir_modules: &[IRModule]) -> // Link to VTK let modules = vec![ "vtksys", - "vtktoken", #(#module_names),* ]; vtk_rs_link::link_cmake_project(modules)?; + println!("cargo:rustc-link-lib=tbb"); Ok(()) } @@ -244,8 +278,11 @@ fn main() -> Result<()> { pretty_env_logger::init(); let args = Args::parse(); - // Obtain all modules - let modules = get_modules(args.wrap_vtk.join("build/xml/vtkCommon*"))?; + // Obtain all modules — scan both vtkCommon* and vtkFiltersSources + let mut modules = get_modules(args.wrap_vtk.join("build/xml/vtkCommon*"))?; + modules.extend(get_modules(args.wrap_vtk.join("build/xml/vtkFiltersSources"))?); + // Sort modules by name to ensure deterministic output + modules.sort_by(|a, b| a.name.cmp(&b.name)); let class_hierarchy = ClassHierarchy::new(&modules)?; diff --git a/vtk-gen/src/parse_cpp.rs b/vtk-gen/src/parse_cpp.rs index 26c70b9..8aa5bba 100644 --- a/vtk-gen/src/parse_cpp.rs +++ b/vtk-gen/src/parse_cpp.rs @@ -37,6 +37,9 @@ impl Parse for Path { #[derive(Debug, PartialEq)] pub enum CppType { Void, + /// Plain `char` (used for C strings and VTK_FILEPATH) + PlainChar, + /// Explicitly signed `signed char` (used for VTK typed data arrays, e.g. vtkSignedCharArray) SignedChar, UnsignedChar, ShortInt, @@ -226,7 +229,7 @@ impl Parse for CppType { "string" => Ok(CppType::String), "type_info" => Ok(TypeInfo), "size_t" => Ok(SizeT), - "char" => Ok(SignedChar), + "char" => Ok(PlainChar), "ostream" => Ok(Ostream), other => { if other.trim().contains(" ") { @@ -279,7 +282,7 @@ mod test { fn parse_types() -> Result<()> { let t0 = "char"; let cpp_type = CppType::parse(t0)?; - assert_eq!(cpp_type, CppType::SignedChar); + assert_eq!(cpp_type, CppType::PlainChar); let t1 = "unsigned char"; let cpp_type = CppType::parse(t1)?; @@ -338,7 +341,7 @@ mod test { let map1 = "std::map"; parse_map!(map1, CppType::Int, CppType::Float); let map2 = "std::map"; - parse_map!(map2, CppType::LongInt, CppType::SignedChar); + parse_map!(map2, CppType::LongInt, CppType::PlainChar); let map3 = "map"; parse_map!(map3, CppType::UnsignedChar, CppType::Double); @@ -364,7 +367,7 @@ mod test { let list1 = "std::list"; parse_list!(list1, CppType::Float); let list2 = "std::list"; - parse_list!(list2, CppType::SignedChar); + parse_list!(list2, CppType::PlainChar); let list3 = "std::list"; parse_list!(list3, CppType::UnsignedChar); let list4 = "std::list>"; @@ -394,7 +397,7 @@ mod test { let vec2 = "std::vector>"; parse_vec!(vec2, CppType::Vec(_)); let vec3 = "vector"; - parse_vec!(vec3, CppType::SignedChar); + parse_vec!(vec3, CppType::PlainChar); Ok(()) } @@ -448,7 +451,7 @@ mod test { ); let generic1 = "json"; - parse_generic!(generic1, "json", [CppType::Int, CppType::SignedChar]); + parse_generic!(generic1, "json", [CppType::Int, CppType::PlainChar]); let generic2 = "what::the"; parse_generic!( generic2, @@ -484,7 +487,7 @@ mod test { let cpp_type = CppType::parse("&float")?; assert_eq!(cpp_type, CppType::Ref(Box::new(CppType::Float))); let cpp_type = CppType::parse("char*")?; - assert_eq!(cpp_type, CppType::Pointer(Box::new(CppType::SignedChar))); + assert_eq!(cpp_type, CppType::Pointer(Box::new(CppType::PlainChar))); let cpp_type = CppType::parse("unsigned char")?; assert_eq!(cpp_type, CppType::UnsignedChar); diff --git a/vtk-gen/src/parse_wrap_vtk_xml.rs b/vtk-gen/src/parse_wrap_vtk_xml.rs index 9d9763f..43cde49 100644 --- a/vtk-gen/src/parse_wrap_vtk_xml.rs +++ b/vtk-gen/src/parse_wrap_vtk_xml.rs @@ -32,7 +32,7 @@ pub fn get_modules(path: impl Into) -> Result> { let files = glob::glob( path.join("*") .to_str() - .context("could not convert path tot string")?, + .context("could not convert path to String")?, )? .map(|x| { let f = x?.to_path_buf(); @@ -216,6 +216,8 @@ pub struct Parameter { #[serde(default = "Default::default")] #[serde(deserialize_with = "option_one_to_bool")] pub reference: bool, + #[serde(rename = "@pointer")] + pub pointer: Option, } #[derive(Deserialize, PartialEq, Debug, Clone)] @@ -300,6 +302,13 @@ pub enum Pointer { Star, #[serde(rename = "**")] StarStar, + /// `** const` in C++ — const outer pointer, double indirection. + /// Treated the same as `**` for binding purposes. + #[serde(rename = "**const")] + StarStarConst, + /// Triple indirection — not bridgeable, causes the method to be skipped. + #[serde(rename = "***")] + StarStarStar, } #[derive(Deserialize, PartialEq, Debug, Clone)] @@ -550,11 +559,13 @@ mod test_parsing { name: Some("os".into()), r#type: "ostream".into(), reference: true, + pointer: None, }, Parameter { name: Some("indent".into()), r#type: "vtkIndent".into(), reference: false, + pointer: None, } ] ); diff --git a/vtk-rs-9.1/build.rs b/vtk-rs-9.1/build.rs index 6654c5d..af9320c 100644 --- a/vtk-rs-9.1/build.rs +++ b/vtk-rs-9.1/build.rs @@ -1,5 +1,5 @@ use cmake::Config; -use vtk_rs_link::{Result, WARN, log}; +use vtk_rs_link::{log, Result, WARN}; fn build_cmake() { println!("cargo:rerun-if-changed=libvtkrs"); let mut config = Config::new("libvtkrs"); @@ -20,8 +20,6 @@ fn main() -> Result<()> { build_cmake(); let modules = vec![ "vtksys", - // "vtktoken", - "vtkCommonArchive", "vtkCommonColor", "vtkCommonComputationalGeometry", "vtkCommonCore", @@ -29,10 +27,11 @@ fn main() -> Result<()> { "vtkCommonExecutionModel", "vtkCommonMath", "vtkCommonMisc", - "vtkCommonPython", "vtkCommonSystem", "vtkCommonTransforms", + "vtkFiltersSources", ]; vtk_rs_link::link_cmake_project(modules)?; + println!("cargo:rustc-link-lib=tbb"); Ok(()) } diff --git a/vtk-rs-9.1/libvtkrs/CMakeLists.txt b/vtk-rs-9.1/libvtkrs/CMakeLists.txt index b178a1c..ab86dd7 100644 --- a/vtk-rs-9.1/libvtkrs/CMakeLists.txt +++ b/vtk-rs-9.1/libvtkrs/CMakeLists.txt @@ -3,7 +3,6 @@ cmake_minimum_required(VERSION 3.12) project(vtkrs) find_package(VTK COMPONENTS - CommonArchive CommonColor CommonComputationalGeometry CommonCore @@ -11,9 +10,9 @@ find_package(VTK COMPONENTS CommonExecutionModel CommonMath CommonMisc - CommonPython CommonSystem CommonTransforms + FiltersSources ) if (NOT VTK_FOUND) @@ -24,7 +23,6 @@ endif() set(CMAKE_NINJA_FORCE_RESPONSE_FILE "ON" CACHE BOOL "Force Ninja to use response files.") add_library(vtkrs STATIC - ${PROJECT_SOURCE_DIR}/include/vtk_common_archive.h ${PROJECT_SOURCE_DIR}/include/vtk_common_color.h ${PROJECT_SOURCE_DIR}/include/vtk_common_computational_geometry.h ${PROJECT_SOURCE_DIR}/include/vtk_common_core.h @@ -32,9 +30,9 @@ add_library(vtkrs STATIC ${PROJECT_SOURCE_DIR}/include/vtk_common_execution_model.h ${PROJECT_SOURCE_DIR}/include/vtk_common_math.h ${PROJECT_SOURCE_DIR}/include/vtk_common_misc.h - ${PROJECT_SOURCE_DIR}/include/vtk_common_python.h ${PROJECT_SOURCE_DIR}/include/vtk_common_system.h ${PROJECT_SOURCE_DIR}/include/vtk_common_transforms.h + ${PROJECT_SOURCE_DIR}/include/vtk_filters_sources.h ) if (VTK094) @@ -44,7 +42,6 @@ endif() include_directories(${PROJECT_SOURCE_DIR}/include/) target_sources(vtkrs PRIVATE - ${PROJECT_SOURCE_DIR}/src/vtk_common_archive.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_color.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_computational_geometry.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_core.cpp @@ -52,9 +49,9 @@ target_sources(vtkrs ${PROJECT_SOURCE_DIR}/src/vtk_common_execution_model.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_math.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_misc.cpp - ${PROJECT_SOURCE_DIR}/src/vtk_common_python.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_system.cpp ${PROJECT_SOURCE_DIR}/src/vtk_common_transforms.cpp + ${PROJECT_SOURCE_DIR}/src/vtk_filters_sources.cpp ) set_target_properties(vtkrs PROPERTIES LINKER_LANGUAGE CXX) diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_archive.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_archive.h index 8d2fd80..b414342 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_archive.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_archive.h @@ -10,6 +10,10 @@ extern "C" vtkNew < vtkBufferedArchiver > vtkBufferedArchiver_new () ; extern "C" void vtkBufferedArchiver_destructor (vtkNew < vtkBufferedArchiver > sself) ; extern "C" void * vtkBufferedArchiver_get_ptr (vtkNew < vtkBufferedArchiver > sself) ; +extern "C" void vtkBufferedArchiver_set_archive_name (vtkNew < vtkBufferedArchiver > sself, const char * name) ; +extern "C" const char * vtkBufferedArchiver_get_archive_name (vtkNew < vtkBufferedArchiver > sself) ; extern "C" vtkNew < vtkPartitionedArchiver > vtkPartitionedArchiver_new () ; extern "C" void vtkPartitionedArchiver_destructor (vtkNew < vtkPartitionedArchiver > sself) ; extern "C" void * vtkPartitionedArchiver_get_ptr (vtkNew < vtkPartitionedArchiver > sself) ; +extern "C" void vtkPartitionedArchiver_set_archive_name (vtkNew < vtkPartitionedArchiver > sself, const char * name) ; +extern "C" const char * vtkPartitionedArchiver_get_archive_name (vtkNew < vtkPartitionedArchiver > sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h index 2ad94d6..a3104ae 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_color.h @@ -7,9 +7,16 @@ #include // Declare exported functions -extern "C" vtkNew < vtkColorSeries > vtkColorSeries_new () ; -extern "C" void vtkColorSeries_destructor (vtkNew < vtkColorSeries > sself) ; -extern "C" void * vtkColorSeries_get_ptr (vtkNew < vtkColorSeries > sself) ; -extern "C" vtkNew < vtkNamedColors > vtkNamedColors_new () ; -extern "C" void vtkNamedColors_destructor (vtkNew < vtkNamedColors > sself) ; -extern "C" void * vtkNamedColors_get_ptr (vtkNew < vtkNamedColors > sself) ; +extern "C" vtkColorSeries * vtkColorSeries_new () ; +extern "C" void vtkColorSeries_destructor (vtkColorSeries * sself) ; +extern "C" void vtk_color_series_set_color_scheme(vtkColorSeries* sself, int scheme); +extern "C" int vtk_color_series_get_number_of_color_schemes(vtkColorSeries* sself); +extern "C" int vtk_color_series_get_color_scheme(vtkColorSeries* sself); +extern "C" int vtk_color_series_get_number_of_colors(vtkColorSeries* sself); +extern "C" void vtk_color_series_set_number_of_colors(vtkColorSeries* sself, int numColors); +extern "C" void vtk_color_series_remove_color(vtkColorSeries* sself, int index); +extern "C" void vtk_color_series_clear_colors(vtkColorSeries* sself); +extern "C" vtkNamedColors * vtkNamedColors_new () ; +extern "C" void vtkNamedColors_destructor (vtkNamedColors * sself) ; +extern "C" int vtk_named_colors_get_number_of_colors(vtkNamedColors* sself); +extern "C" void vtk_named_colors_reset_colors(vtkNamedColors* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h index c7d8ace..7707502 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_computational_geometry.h @@ -31,75 +31,191 @@ #include // Declare exported functions -extern "C" vtkNew < vtkCardinalSpline > vtkCardinalSpline_new () ; -extern "C" void vtkCardinalSpline_destructor (vtkNew < vtkCardinalSpline > sself) ; -extern "C" void * vtkCardinalSpline_get_ptr (vtkNew < vtkCardinalSpline > sself) ; -extern "C" vtkNew < vtkKochanekSpline > vtkKochanekSpline_new () ; -extern "C" void vtkKochanekSpline_destructor (vtkNew < vtkKochanekSpline > sself) ; -extern "C" void * vtkKochanekSpline_get_ptr (vtkNew < vtkKochanekSpline > sself) ; -extern "C" vtkNew < vtkParametricBohemianDome > vtkParametricBohemianDome_new () ; -extern "C" void vtkParametricBohemianDome_destructor (vtkNew < vtkParametricBohemianDome > sself) ; -extern "C" void * vtkParametricBohemianDome_get_ptr (vtkNew < vtkParametricBohemianDome > sself) ; -extern "C" vtkNew < vtkParametricBour > vtkParametricBour_new () ; -extern "C" void vtkParametricBour_destructor (vtkNew < vtkParametricBour > sself) ; -extern "C" void * vtkParametricBour_get_ptr (vtkNew < vtkParametricBour > sself) ; -extern "C" vtkNew < vtkParametricBoy > vtkParametricBoy_new () ; -extern "C" void vtkParametricBoy_destructor (vtkNew < vtkParametricBoy > sself) ; -extern "C" void * vtkParametricBoy_get_ptr (vtkNew < vtkParametricBoy > sself) ; -extern "C" vtkNew < vtkParametricCatalanMinimal > vtkParametricCatalanMinimal_new () ; -extern "C" void vtkParametricCatalanMinimal_destructor (vtkNew < vtkParametricCatalanMinimal > sself) ; -extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkNew < vtkParametricCatalanMinimal > sself) ; -extern "C" vtkNew < vtkParametricConicSpiral > vtkParametricConicSpiral_new () ; -extern "C" void vtkParametricConicSpiral_destructor (vtkNew < vtkParametricConicSpiral > sself) ; -extern "C" void * vtkParametricConicSpiral_get_ptr (vtkNew < vtkParametricConicSpiral > sself) ; -extern "C" vtkNew < vtkParametricCrossCap > vtkParametricCrossCap_new () ; -extern "C" void vtkParametricCrossCap_destructor (vtkNew < vtkParametricCrossCap > sself) ; -extern "C" void * vtkParametricCrossCap_get_ptr (vtkNew < vtkParametricCrossCap > sself) ; -extern "C" vtkNew < vtkParametricDini > vtkParametricDini_new () ; -extern "C" void vtkParametricDini_destructor (vtkNew < vtkParametricDini > sself) ; -extern "C" void * vtkParametricDini_get_ptr (vtkNew < vtkParametricDini > sself) ; -extern "C" vtkNew < vtkParametricEllipsoid > vtkParametricEllipsoid_new () ; -extern "C" void vtkParametricEllipsoid_destructor (vtkNew < vtkParametricEllipsoid > sself) ; -extern "C" void * vtkParametricEllipsoid_get_ptr (vtkNew < vtkParametricEllipsoid > sself) ; -extern "C" vtkNew < vtkParametricEnneper > vtkParametricEnneper_new () ; -extern "C" void vtkParametricEnneper_destructor (vtkNew < vtkParametricEnneper > sself) ; -extern "C" void * vtkParametricEnneper_get_ptr (vtkNew < vtkParametricEnneper > sself) ; -extern "C" vtkNew < vtkParametricFigure8Klein > vtkParametricFigure8Klein_new () ; -extern "C" void vtkParametricFigure8Klein_destructor (vtkNew < vtkParametricFigure8Klein > sself) ; -extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkNew < vtkParametricFigure8Klein > sself) ; -extern "C" vtkNew < vtkParametricHenneberg > vtkParametricHenneberg_new () ; -extern "C" void vtkParametricHenneberg_destructor (vtkNew < vtkParametricHenneberg > sself) ; -extern "C" void * vtkParametricHenneberg_get_ptr (vtkNew < vtkParametricHenneberg > sself) ; -extern "C" vtkNew < vtkParametricKlein > vtkParametricKlein_new () ; -extern "C" void vtkParametricKlein_destructor (vtkNew < vtkParametricKlein > sself) ; -extern "C" void * vtkParametricKlein_get_ptr (vtkNew < vtkParametricKlein > sself) ; -extern "C" vtkNew < vtkParametricKuen > vtkParametricKuen_new () ; -extern "C" void vtkParametricKuen_destructor (vtkNew < vtkParametricKuen > sself) ; -extern "C" void * vtkParametricKuen_get_ptr (vtkNew < vtkParametricKuen > sself) ; -extern "C" vtkNew < vtkParametricMobius > vtkParametricMobius_new () ; -extern "C" void vtkParametricMobius_destructor (vtkNew < vtkParametricMobius > sself) ; -extern "C" void * vtkParametricMobius_get_ptr (vtkNew < vtkParametricMobius > sself) ; -extern "C" vtkNew < vtkParametricPluckerConoid > vtkParametricPluckerConoid_new () ; -extern "C" void vtkParametricPluckerConoid_destructor (vtkNew < vtkParametricPluckerConoid > sself) ; -extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkNew < vtkParametricPluckerConoid > sself) ; -extern "C" vtkNew < vtkParametricPseudosphere > vtkParametricPseudosphere_new () ; -extern "C" void vtkParametricPseudosphere_destructor (vtkNew < vtkParametricPseudosphere > sself) ; -extern "C" void * vtkParametricPseudosphere_get_ptr (vtkNew < vtkParametricPseudosphere > sself) ; -extern "C" vtkNew < vtkParametricRandomHills > vtkParametricRandomHills_new () ; -extern "C" void vtkParametricRandomHills_destructor (vtkNew < vtkParametricRandomHills > sself) ; -extern "C" void * vtkParametricRandomHills_get_ptr (vtkNew < vtkParametricRandomHills > sself) ; -extern "C" vtkNew < vtkParametricRoman > vtkParametricRoman_new () ; -extern "C" void vtkParametricRoman_destructor (vtkNew < vtkParametricRoman > sself) ; -extern "C" void * vtkParametricRoman_get_ptr (vtkNew < vtkParametricRoman > sself) ; -extern "C" vtkNew < vtkParametricSpline > vtkParametricSpline_new () ; -extern "C" void vtkParametricSpline_destructor (vtkNew < vtkParametricSpline > sself) ; -extern "C" void * vtkParametricSpline_get_ptr (vtkNew < vtkParametricSpline > sself) ; -extern "C" vtkNew < vtkParametricSuperEllipsoid > vtkParametricSuperEllipsoid_new () ; -extern "C" void vtkParametricSuperEllipsoid_destructor (vtkNew < vtkParametricSuperEllipsoid > sself) ; -extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkNew < vtkParametricSuperEllipsoid > sself) ; -extern "C" vtkNew < vtkParametricSuperToroid > vtkParametricSuperToroid_new () ; -extern "C" void vtkParametricSuperToroid_destructor (vtkNew < vtkParametricSuperToroid > sself) ; -extern "C" void * vtkParametricSuperToroid_get_ptr (vtkNew < vtkParametricSuperToroid > sself) ; -extern "C" vtkNew < vtkParametricTorus > vtkParametricTorus_new () ; -extern "C" void vtkParametricTorus_destructor (vtkNew < vtkParametricTorus > sself) ; -extern "C" void * vtkParametricTorus_get_ptr (vtkNew < vtkParametricTorus > sself) ; +extern "C" vtkCardinalSpline * vtkCardinalSpline_new () ; +extern "C" void vtkCardinalSpline_destructor (vtkCardinalSpline * sself) ; +extern "C" void vtk_cardinal_spline_compute(vtkCardinalSpline* sself); +extern "C" double vtk_cardinal_spline_evaluate(vtkCardinalSpline* sself, double t); +extern "C" vtkKochanekSpline * vtkKochanekSpline_new () ; +extern "C" void vtkKochanekSpline_destructor (vtkKochanekSpline * sself) ; +extern "C" void vtk_kochanek_spline_compute(vtkKochanekSpline* sself); +extern "C" double vtk_kochanek_spline_evaluate(vtkKochanekSpline* sself, double t); +extern "C" void vtk_kochanek_spline_set_default_bias(vtkKochanekSpline* sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_bias(vtkKochanekSpline* sself); +extern "C" void vtk_kochanek_spline_set_default_tension(vtkKochanekSpline* sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_tension(vtkKochanekSpline* sself); +extern "C" void vtk_kochanek_spline_set_default_continuity(vtkKochanekSpline* sself, double _arg); +extern "C" double vtk_kochanek_spline_get_default_continuity(vtkKochanekSpline* sself); +extern "C" vtkParametricBohemianDome * vtkParametricBohemianDome_new () ; +extern "C" void vtkParametricBohemianDome_destructor (vtkParametricBohemianDome * sself) ; +extern "C" double vtk_parametric_bohemian_dome_get_a(vtkParametricBohemianDome* sself); +extern "C" void vtk_parametric_bohemian_dome_set_a(vtkParametricBohemianDome* sself, double _arg); +extern "C" double vtk_parametric_bohemian_dome_get_b(vtkParametricBohemianDome* sself); +extern "C" void vtk_parametric_bohemian_dome_set_b(vtkParametricBohemianDome* sself, double _arg); +extern "C" double vtk_parametric_bohemian_dome_get_c(vtkParametricBohemianDome* sself); +extern "C" void vtk_parametric_bohemian_dome_set_c(vtkParametricBohemianDome* sself, double _arg); +extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkParametricBohemianDome* sself); +extern "C" vtkParametricBour * vtkParametricBour_new () ; +extern "C" void vtkParametricBour_destructor (vtkParametricBour * sself) ; +extern "C" int vtk_parametric_bour_get_dimension(vtkParametricBour* sself); +extern "C" vtkParametricBoy * vtkParametricBoy_new () ; +extern "C" void vtkParametricBoy_destructor (vtkParametricBoy * sself) ; +extern "C" int vtk_parametric_boy_get_dimension(vtkParametricBoy* sself); +extern "C" void vtk_parametric_boy_set_z_scale(vtkParametricBoy* sself, double _arg); +extern "C" double vtk_parametric_boy_get_z_scale(vtkParametricBoy* sself); +extern "C" vtkParametricCatalanMinimal * vtkParametricCatalanMinimal_new () ; +extern "C" void vtkParametricCatalanMinimal_destructor (vtkParametricCatalanMinimal * sself) ; +extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkParametricCatalanMinimal* sself); +extern "C" vtkParametricConicSpiral * vtkParametricConicSpiral_new () ; +extern "C" void vtkParametricConicSpiral_destructor (vtkParametricConicSpiral * sself) ; +extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkParametricConicSpiral* sself); +extern "C" void vtk_parametric_conic_spiral_set_a(vtkParametricConicSpiral* sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_a(vtkParametricConicSpiral* sself); +extern "C" void vtk_parametric_conic_spiral_set_b(vtkParametricConicSpiral* sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_b(vtkParametricConicSpiral* sself); +extern "C" void vtk_parametric_conic_spiral_set_c(vtkParametricConicSpiral* sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_c(vtkParametricConicSpiral* sself); +extern "C" void vtk_parametric_conic_spiral_set_n(vtkParametricConicSpiral* sself, double _arg); +extern "C" double vtk_parametric_conic_spiral_get_n(vtkParametricConicSpiral* sself); +extern "C" vtkParametricCrossCap * vtkParametricCrossCap_new () ; +extern "C" void vtkParametricCrossCap_destructor (vtkParametricCrossCap * sself) ; +extern "C" int vtk_parametric_cross_cap_get_dimension(vtkParametricCrossCap* sself); +extern "C" vtkParametricDini * vtkParametricDini_new () ; +extern "C" void vtkParametricDini_destructor (vtkParametricDini * sself) ; +extern "C" int vtk_parametric_dini_get_dimension(vtkParametricDini* sself); +extern "C" void vtk_parametric_dini_set_a(vtkParametricDini* sself, double _arg); +extern "C" double vtk_parametric_dini_get_a(vtkParametricDini* sself); +extern "C" void vtk_parametric_dini_set_b(vtkParametricDini* sself, double _arg); +extern "C" double vtk_parametric_dini_get_b(vtkParametricDini* sself); +extern "C" vtkParametricEllipsoid * vtkParametricEllipsoid_new () ; +extern "C" void vtkParametricEllipsoid_destructor (vtkParametricEllipsoid * sself) ; +extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkParametricEllipsoid* sself); +extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkParametricEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkParametricEllipsoid* sself); +extern "C" void vtk_parametric_ellipsoid_set_y_radius(vtkParametricEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_y_radius(vtkParametricEllipsoid* sself); +extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkParametricEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkParametricEllipsoid* sself); +extern "C" vtkParametricEnneper * vtkParametricEnneper_new () ; +extern "C" void vtkParametricEnneper_destructor (vtkParametricEnneper * sself) ; +extern "C" int vtk_parametric_enneper_get_dimension(vtkParametricEnneper* sself); +extern "C" vtkParametricFigure8Klein * vtkParametricFigure8Klein_new () ; +extern "C" void vtkParametricFigure8Klein_destructor (vtkParametricFigure8Klein * sself) ; +extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkParametricFigure8Klein* sself, double _arg); +extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkParametricFigure8Klein* sself); +extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkParametricFigure8Klein* sself); +extern "C" vtkParametricHenneberg * vtkParametricHenneberg_new () ; +extern "C" void vtkParametricHenneberg_destructor (vtkParametricHenneberg * sself) ; +extern "C" int vtk_parametric_henneberg_get_dimension(vtkParametricHenneberg* sself); +extern "C" vtkParametricKlein * vtkParametricKlein_new () ; +extern "C" void vtkParametricKlein_destructor (vtkParametricKlein * sself) ; +extern "C" int vtk_parametric_klein_get_dimension(vtkParametricKlein* sself); +extern "C" vtkParametricKuen * vtkParametricKuen_new () ; +extern "C" void vtkParametricKuen_destructor (vtkParametricKuen * sself) ; +extern "C" int vtk_parametric_kuen_get_dimension(vtkParametricKuen* sself); +extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkParametricKuen* sself, double _arg); +extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkParametricKuen* sself); +extern "C" vtkParametricMobius * vtkParametricMobius_new () ; +extern "C" void vtkParametricMobius_destructor (vtkParametricMobius * sself) ; +extern "C" void vtk_parametric_mobius_set_radius(vtkParametricMobius* sself, double _arg); +extern "C" double vtk_parametric_mobius_get_radius(vtkParametricMobius* sself); +extern "C" int vtk_parametric_mobius_get_dimension(vtkParametricMobius* sself); +extern "C" vtkParametricPluckerConoid * vtkParametricPluckerConoid_new () ; +extern "C" void vtkParametricPluckerConoid_destructor (vtkParametricPluckerConoid * sself) ; +extern "C" int vtk_parametric_plucker_conoid_get_n(vtkParametricPluckerConoid* sself); +extern "C" void vtk_parametric_plucker_conoid_set_n(vtkParametricPluckerConoid* sself, int _arg); +extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkParametricPluckerConoid* sself); +extern "C" vtkParametricPseudosphere * vtkParametricPseudosphere_new () ; +extern "C" void vtkParametricPseudosphere_destructor (vtkParametricPseudosphere * sself) ; +extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkParametricPseudosphere* sself); +extern "C" vtkParametricRandomHills * vtkParametricRandomHills_new () ; +extern "C" void vtkParametricRandomHills_destructor (vtkParametricRandomHills * sself) ; +extern "C" int vtk_parametric_random_hills_get_dimension(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkParametricRandomHills* sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_hill_x_variance(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_x_variance(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_hill_y_variance(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_y_variance(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_hill_amplitude(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_hill_amplitude(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_random_seed(vtkParametricRandomHills* sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_random_seed(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_allow_random_generation(vtkParametricRandomHills* sself, int _arg); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_min_value(vtkParametricRandomHills* sself); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_max_value(vtkParametricRandomHills* sself); +extern "C" int vtk_parametric_random_hills_get_allow_random_generation(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_allow_random_generation_on(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_allow_random_generation_off(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_x_variance_scale_factor(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_x_variance_scale_factor(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_y_variance_scale_factor(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_y_variance_scale_factor(vtkParametricRandomHills* sself); +extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkParametricRandomHills* sself, double _arg); +extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkParametricRandomHills* sself); +extern "C" vtkParametricRoman * vtkParametricRoman_new () ; +extern "C" void vtkParametricRoman_destructor (vtkParametricRoman * sself) ; +extern "C" int vtk_parametric_roman_get_dimension(vtkParametricRoman* sself); +extern "C" void vtk_parametric_roman_set_radius(vtkParametricRoman* sself, double _arg); +extern "C" double vtk_parametric_roman_get_radius(vtkParametricRoman* sself); +extern "C" vtkParametricSpline * vtkParametricSpline_new () ; +extern "C" void vtkParametricSpline_destructor (vtkParametricSpline * sself) ; +extern "C" int vtk_parametric_spline_get_dimension(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_number_of_points(vtkParametricSpline* sself, long long numPts); +extern "C" void vtk_parametric_spline_set_point(vtkParametricSpline* sself, long long index, double x, double y, double z); +extern "C" void vtk_parametric_spline_set_closed(vtkParametricSpline* sself, int _arg); +extern "C" int vtk_parametric_spline_get_closed(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_closed_on(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_closed_off(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_parameterize_by_length(vtkParametricSpline* sself, int _arg); +extern "C" int vtk_parametric_spline_get_parameterize_by_length(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_parameterize_by_length_on(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_parameterize_by_length_off(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_left_constraint(vtkParametricSpline* sself, int _arg); +extern "C" int vtk_parametric_spline_get_left_constraint_min_value(vtkParametricSpline* sself); +extern "C" int vtk_parametric_spline_get_left_constraint_max_value(vtkParametricSpline* sself); +extern "C" int vtk_parametric_spline_get_left_constraint(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_right_constraint(vtkParametricSpline* sself, int _arg); +extern "C" int vtk_parametric_spline_get_right_constraint_min_value(vtkParametricSpline* sself); +extern "C" int vtk_parametric_spline_get_right_constraint_max_value(vtkParametricSpline* sself); +extern "C" int vtk_parametric_spline_get_right_constraint(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_left_value(vtkParametricSpline* sself, double _arg); +extern "C" double vtk_parametric_spline_get_left_value(vtkParametricSpline* sself); +extern "C" void vtk_parametric_spline_set_right_value(vtkParametricSpline* sself, double _arg); +extern "C" double vtk_parametric_spline_get_right_value(vtkParametricSpline* sself); +extern "C" vtkParametricSuperEllipsoid * vtkParametricSuperEllipsoid_new () ; +extern "C" void vtkParametricSuperEllipsoid_destructor (vtkParametricSuperEllipsoid * sself) ; +extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_y_radius(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_y_radius(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_z_radius(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_z_radius(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_n_1(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_n_1(vtkParametricSuperEllipsoid* sself); +extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkParametricSuperEllipsoid* sself, double _arg); +extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkParametricSuperEllipsoid* sself); +extern "C" vtkParametricSuperToroid * vtkParametricSuperToroid_new () ; +extern "C" void vtkParametricSuperToroid_destructor (vtkParametricSuperToroid * sself) ; +extern "C" int vtk_parametric_super_toroid_get_dimension(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_cross_section_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_cross_section_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_x_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_x_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_y_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_y_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_z_radius(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_z_radius(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_n_1(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_n_1(vtkParametricSuperToroid* sself); +extern "C" void vtk_parametric_super_toroid_set_n_2(vtkParametricSuperToroid* sself, double _arg); +extern "C" double vtk_parametric_super_toroid_get_n_2(vtkParametricSuperToroid* sself); +extern "C" vtkParametricTorus * vtkParametricTorus_new () ; +extern "C" void vtkParametricTorus_destructor (vtkParametricTorus * sself) ; +extern "C" void vtk_parametric_torus_set_ring_radius(vtkParametricTorus* sself, double _arg); +extern "C" double vtk_parametric_torus_get_ring_radius(vtkParametricTorus* sself); +extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkParametricTorus* sself, double _arg); +extern "C" double vtk_parametric_torus_get_cross_section_radius(vtkParametricTorus* sself); +extern "C" int vtk_parametric_torus_get_dimension(vtkParametricTorus* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h index 62c7072..c38f884 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_core.h @@ -16,7 +16,6 @@ #include #include #include -#include #include #include #include @@ -145,6 +144,8 @@ #include #include #include +#include +#include #include #include #include @@ -161,228 +162,735 @@ #include // Declare exported functions -extern "C" vtkNew < vtkAnimationCue > vtkAnimationCue_new () ; -extern "C" void vtkAnimationCue_destructor (vtkNew < vtkAnimationCue > sself) ; -extern "C" void * vtkAnimationCue_get_ptr (vtkNew < vtkAnimationCue > sself) ; -extern "C" vtkNew < vtkArchiver > vtkArchiver_new () ; -extern "C" void vtkArchiver_destructor (vtkNew < vtkArchiver > sself) ; -extern "C" void * vtkArchiver_get_ptr (vtkNew < vtkArchiver > sself) ; -extern "C" vtkNew < vtkBitArray > vtkBitArray_new () ; -extern "C" void vtkBitArray_destructor (vtkNew < vtkBitArray > sself) ; -extern "C" void * vtkBitArray_get_ptr (vtkNew < vtkBitArray > sself) ; -extern "C" vtkNew < vtkBitArrayIterator > vtkBitArrayIterator_new () ; -extern "C" void vtkBitArrayIterator_destructor (vtkNew < vtkBitArrayIterator > sself) ; -extern "C" void * vtkBitArrayIterator_get_ptr (vtkNew < vtkBitArrayIterator > sself) ; -extern "C" vtkNew < vtkBoxMuellerRandomSequence > vtkBoxMuellerRandomSequence_new () ; -extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkNew < vtkBoxMuellerRandomSequence > sself) ; -extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkNew < vtkBoxMuellerRandomSequence > sself) ; -extern "C" vtkNew < vtkByteSwap > vtkByteSwap_new () ; -extern "C" void vtkByteSwap_destructor (vtkNew < vtkByteSwap > sself) ; -extern "C" void * vtkByteSwap_get_ptr (vtkNew < vtkByteSwap > sself) ; -extern "C" vtkNew < vtkCallbackCommand > vtkCallbackCommand_new () ; -extern "C" void vtkCallbackCommand_destructor (vtkNew < vtkCallbackCommand > sself) ; -extern "C" void * vtkCallbackCommand_get_ptr (vtkNew < vtkCallbackCommand > sself) ; -extern "C" vtkNew < vtkCharArray > vtkCharArray_new () ; -extern "C" void vtkCharArray_destructor (vtkNew < vtkCharArray > sself) ; -extern "C" void * vtkCharArray_get_ptr (vtkNew < vtkCharArray > sself) ; -extern "C" vtkNew < vtkCollection > vtkCollection_new () ; -extern "C" void vtkCollection_destructor (vtkNew < vtkCollection > sself) ; -extern "C" void * vtkCollection_get_ptr (vtkNew < vtkCollection > sself) ; -extern "C" vtkNew < vtkCollectionIterator > vtkCollectionIterator_new () ; -extern "C" void vtkCollectionIterator_destructor (vtkNew < vtkCollectionIterator > sself) ; -extern "C" void * vtkCollectionIterator_get_ptr (vtkNew < vtkCollectionIterator > sself) ; -extern "C" vtkNew < vtkCriticalSection > vtkCriticalSection_new () ; -extern "C" void vtkCriticalSection_destructor (vtkNew < vtkCriticalSection > sself) ; -extern "C" void * vtkCriticalSection_get_ptr (vtkNew < vtkCriticalSection > sself) ; -extern "C" vtkNew < vtkDataArrayCollection > vtkDataArrayCollection_new () ; -extern "C" void vtkDataArrayCollection_destructor (vtkNew < vtkDataArrayCollection > sself) ; -extern "C" void * vtkDataArrayCollection_get_ptr (vtkNew < vtkDataArrayCollection > sself) ; -extern "C" vtkNew < vtkDataArrayCollectionIterator > vtkDataArrayCollectionIterator_new () ; -extern "C" void vtkDataArrayCollectionIterator_destructor (vtkNew < vtkDataArrayCollectionIterator > sself) ; -extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkNew < vtkDataArrayCollectionIterator > sself) ; -extern "C" vtkNew < vtkDataArraySelection > vtkDataArraySelection_new () ; -extern "C" void vtkDataArraySelection_destructor (vtkNew < vtkDataArraySelection > sself) ; -extern "C" void * vtkDataArraySelection_get_ptr (vtkNew < vtkDataArraySelection > sself) ; -extern "C" vtkNew < vtkDebugLeaks > vtkDebugLeaks_new () ; -extern "C" void vtkDebugLeaks_destructor (vtkNew < vtkDebugLeaks > sself) ; -extern "C" void * vtkDebugLeaks_get_ptr (vtkNew < vtkDebugLeaks > sself) ; -extern "C" vtkNew < vtkDoubleArray > vtkDoubleArray_new () ; -extern "C" void vtkDoubleArray_destructor (vtkNew < vtkDoubleArray > sself) ; -extern "C" void * vtkDoubleArray_get_ptr (vtkNew < vtkDoubleArray > sself) ; -extern "C" vtkNew < vtkDynamicLoader > vtkDynamicLoader_new () ; -extern "C" void vtkDynamicLoader_destructor (vtkNew < vtkDynamicLoader > sself) ; -extern "C" void * vtkDynamicLoader_get_ptr (vtkNew < vtkDynamicLoader > sself) ; -extern "C" vtkNew < vtkEventDataDevice3D > vtkEventDataDevice3D_new () ; -extern "C" void vtkEventDataDevice3D_destructor (vtkNew < vtkEventDataDevice3D > sself) ; -extern "C" void * vtkEventDataDevice3D_get_ptr (vtkNew < vtkEventDataDevice3D > sself) ; -extern "C" vtkNew < vtkEventDataForDevice > vtkEventDataForDevice_new () ; -extern "C" void vtkEventDataForDevice_destructor (vtkNew < vtkEventDataForDevice > sself) ; -extern "C" void * vtkEventDataForDevice_get_ptr (vtkNew < vtkEventDataForDevice > sself) ; -extern "C" vtkNew < vtkEventForwarderCommand > vtkEventForwarderCommand_new () ; -extern "C" void vtkEventForwarderCommand_destructor (vtkNew < vtkEventForwarderCommand > sself) ; -extern "C" void * vtkEventForwarderCommand_get_ptr (vtkNew < vtkEventForwarderCommand > sself) ; -extern "C" vtkNew < vtkFileOutputWindow > vtkFileOutputWindow_new () ; -extern "C" void vtkFileOutputWindow_destructor (vtkNew < vtkFileOutputWindow > sself) ; -extern "C" void * vtkFileOutputWindow_get_ptr (vtkNew < vtkFileOutputWindow > sself) ; -extern "C" vtkNew < vtkFloatArray > vtkFloatArray_new () ; -extern "C" void vtkFloatArray_destructor (vtkNew < vtkFloatArray > sself) ; -extern "C" void * vtkFloatArray_get_ptr (vtkNew < vtkFloatArray > sself) ; -extern "C" vtkNew < vtkGarbageCollector > vtkGarbageCollector_new () ; -extern "C" void vtkGarbageCollector_destructor (vtkNew < vtkGarbageCollector > sself) ; -extern "C" void * vtkGarbageCollector_get_ptr (vtkNew < vtkGarbageCollector > sself) ; -extern "C" vtkNew < vtkIdList > vtkIdList_new () ; -extern "C" void vtkIdList_destructor (vtkNew < vtkIdList > sself) ; -extern "C" void * vtkIdList_get_ptr (vtkNew < vtkIdList > sself) ; -extern "C" vtkNew < vtkIdListCollection > vtkIdListCollection_new () ; -extern "C" void vtkIdListCollection_destructor (vtkNew < vtkIdListCollection > sself) ; -extern "C" void * vtkIdListCollection_get_ptr (vtkNew < vtkIdListCollection > sself) ; -extern "C" vtkNew < vtkIdTypeArray > vtkIdTypeArray_new () ; -extern "C" void vtkIdTypeArray_destructor (vtkNew < vtkIdTypeArray > sself) ; -extern "C" void * vtkIdTypeArray_get_ptr (vtkNew < vtkIdTypeArray > sself) ; -extern "C" vtkNew < vtkInformation > vtkInformation_new () ; -extern "C" void vtkInformation_destructor (vtkNew < vtkInformation > sself) ; -extern "C" void * vtkInformation_get_ptr (vtkNew < vtkInformation > sself) ; -extern "C" vtkNew < vtkInformationIterator > vtkInformationIterator_new () ; -extern "C" void vtkInformationIterator_destructor (vtkNew < vtkInformationIterator > sself) ; -extern "C" void * vtkInformationIterator_get_ptr (vtkNew < vtkInformationIterator > sself) ; -extern "C" vtkNew < vtkInformationKeyLookup > vtkInformationKeyLookup_new () ; -extern "C" void vtkInformationKeyLookup_destructor (vtkNew < vtkInformationKeyLookup > sself) ; -extern "C" void * vtkInformationKeyLookup_get_ptr (vtkNew < vtkInformationKeyLookup > sself) ; -extern "C" vtkNew < vtkInformationVector > vtkInformationVector_new () ; -extern "C" void vtkInformationVector_destructor (vtkNew < vtkInformationVector > sself) ; -extern "C" void * vtkInformationVector_get_ptr (vtkNew < vtkInformationVector > sself) ; -extern "C" vtkNew < vtkIntArray > vtkIntArray_new () ; -extern "C" void vtkIntArray_destructor (vtkNew < vtkIntArray > sself) ; -extern "C" void * vtkIntArray_get_ptr (vtkNew < vtkIntArray > sself) ; -extern "C" vtkNew < vtkLongArray > vtkLongArray_new () ; -extern "C" void vtkLongArray_destructor (vtkNew < vtkLongArray > sself) ; -extern "C" void * vtkLongArray_get_ptr (vtkNew < vtkLongArray > sself) ; -extern "C" vtkNew < vtkLongLongArray > vtkLongLongArray_new () ; -extern "C" void vtkLongLongArray_destructor (vtkNew < vtkLongLongArray > sself) ; -extern "C" void * vtkLongLongArray_get_ptr (vtkNew < vtkLongLongArray > sself) ; -extern "C" vtkNew < vtkLookupTable > vtkLookupTable_new () ; -extern "C" void vtkLookupTable_destructor (vtkNew < vtkLookupTable > sself) ; -extern "C" void * vtkLookupTable_get_ptr (vtkNew < vtkLookupTable > sself) ; -extern "C" vtkNew < vtkMath > vtkMath_new () ; -extern "C" void vtkMath_destructor (vtkNew < vtkMath > sself) ; -extern "C" void * vtkMath_get_ptr (vtkNew < vtkMath > sself) ; -extern "C" vtkNew < vtkMersenneTwister > vtkMersenneTwister_new () ; -extern "C" void vtkMersenneTwister_destructor (vtkNew < vtkMersenneTwister > sself) ; -extern "C" void * vtkMersenneTwister_get_ptr (vtkNew < vtkMersenneTwister > sself) ; -extern "C" vtkNew < vtkMinimalStandardRandomSequence > vtkMinimalStandardRandomSequence_new () ; -extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkNew < vtkMinimalStandardRandomSequence > sself) ; -extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkNew < vtkMinimalStandardRandomSequence > sself) ; -extern "C" vtkNew < vtkMultiThreader > vtkMultiThreader_new () ; -extern "C" void vtkMultiThreader_destructor (vtkNew < vtkMultiThreader > sself) ; -extern "C" void * vtkMultiThreader_get_ptr (vtkNew < vtkMultiThreader > sself) ; -extern "C" vtkNew < vtkObject > vtkObject_new () ; -extern "C" void vtkObject_destructor (vtkNew < vtkObject > sself) ; -extern "C" void * vtkObject_get_ptr (vtkNew < vtkObject > sself) ; -extern "C" vtkNew < vtkObjectFactoryCollection > vtkObjectFactoryCollection_new () ; -extern "C" void vtkObjectFactoryCollection_destructor (vtkNew < vtkObjectFactoryCollection > sself) ; -extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkNew < vtkObjectFactoryCollection > sself) ; -extern "C" vtkNew < vtkOldStyleCallbackCommand > vtkOldStyleCallbackCommand_new () ; -extern "C" void vtkOldStyleCallbackCommand_destructor (vtkNew < vtkOldStyleCallbackCommand > sself) ; -extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkNew < vtkOldStyleCallbackCommand > sself) ; -extern "C" vtkNew < vtkOutputWindow > vtkOutputWindow_new () ; -extern "C" void vtkOutputWindow_destructor (vtkNew < vtkOutputWindow > sself) ; -extern "C" void * vtkOutputWindow_get_ptr (vtkNew < vtkOutputWindow > sself) ; -extern "C" vtkNew < vtkOverrideInformationCollection > vtkOverrideInformationCollection_new () ; -extern "C" void vtkOverrideInformationCollection_destructor (vtkNew < vtkOverrideInformationCollection > sself) ; -extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkNew < vtkOverrideInformationCollection > sself) ; -extern "C" vtkNew < vtkPoints > vtkPoints_new () ; -extern "C" void vtkPoints_destructor (vtkNew < vtkPoints > sself) ; -extern "C" void * vtkPoints_get_ptr (vtkNew < vtkPoints > sself) ; -extern "C" vtkNew < vtkPoints2D > vtkPoints2D_new () ; -extern "C" void vtkPoints2D_destructor (vtkNew < vtkPoints2D > sself) ; -extern "C" void * vtkPoints2D_get_ptr (vtkNew < vtkPoints2D > sself) ; -extern "C" vtkNew < vtkPriorityQueue > vtkPriorityQueue_new () ; -extern "C" void vtkPriorityQueue_destructor (vtkNew < vtkPriorityQueue > sself) ; -extern "C" void * vtkPriorityQueue_get_ptr (vtkNew < vtkPriorityQueue > sself) ; -extern "C" vtkNew < vtkRandomPool > vtkRandomPool_new () ; -extern "C" void vtkRandomPool_destructor (vtkNew < vtkRandomPool > sself) ; -extern "C" void * vtkRandomPool_get_ptr (vtkNew < vtkRandomPool > sself) ; -extern "C" vtkNew < vtkReferenceCount > vtkReferenceCount_new () ; -extern "C" void vtkReferenceCount_destructor (vtkNew < vtkReferenceCount > sself) ; -extern "C" void * vtkReferenceCount_get_ptr (vtkNew < vtkReferenceCount > sself) ; -extern "C" vtkNew < vtkScalarsToColors > vtkScalarsToColors_new () ; -extern "C" void vtkScalarsToColors_destructor (vtkNew < vtkScalarsToColors > sself) ; -extern "C" void * vtkScalarsToColors_get_ptr (vtkNew < vtkScalarsToColors > sself) ; -extern "C" vtkNew < vtkShortArray > vtkShortArray_new () ; -extern "C" void vtkShortArray_destructor (vtkNew < vtkShortArray > sself) ; -extern "C" void * vtkShortArray_get_ptr (vtkNew < vtkShortArray > sself) ; -extern "C" vtkNew < vtkSignedCharArray > vtkSignedCharArray_new () ; -extern "C" void vtkSignedCharArray_destructor (vtkNew < vtkSignedCharArray > sself) ; -extern "C" void * vtkSignedCharArray_get_ptr (vtkNew < vtkSignedCharArray > sself) ; -extern "C" vtkNew < vtkSortDataArray > vtkSortDataArray_new () ; -extern "C" void vtkSortDataArray_destructor (vtkNew < vtkSortDataArray > sself) ; -extern "C" void * vtkSortDataArray_get_ptr (vtkNew < vtkSortDataArray > sself) ; -extern "C" vtkNew < vtkStringArray > vtkStringArray_new () ; -extern "C" void vtkStringArray_destructor (vtkNew < vtkStringArray > sself) ; -extern "C" void * vtkStringArray_get_ptr (vtkNew < vtkStringArray > sself) ; -extern "C" vtkNew < vtkStringOutputWindow > vtkStringOutputWindow_new () ; -extern "C" void vtkStringOutputWindow_destructor (vtkNew < vtkStringOutputWindow > sself) ; -extern "C" void * vtkStringOutputWindow_get_ptr (vtkNew < vtkStringOutputWindow > sself) ; -extern "C" vtkNew < vtkTimePointUtility > vtkTimePointUtility_new () ; -extern "C" void vtkTimePointUtility_destructor (vtkNew < vtkTimePointUtility > sself) ; -extern "C" void * vtkTimePointUtility_get_ptr (vtkNew < vtkTimePointUtility > sself) ; -extern "C" vtkNew < vtkTypeFloat32Array > vtkTypeFloat32Array_new () ; -extern "C" void vtkTypeFloat32Array_destructor (vtkNew < vtkTypeFloat32Array > sself) ; -extern "C" void * vtkTypeFloat32Array_get_ptr (vtkNew < vtkTypeFloat32Array > sself) ; -extern "C" vtkNew < vtkTypeFloat64Array > vtkTypeFloat64Array_new () ; -extern "C" void vtkTypeFloat64Array_destructor (vtkNew < vtkTypeFloat64Array > sself) ; -extern "C" void * vtkTypeFloat64Array_get_ptr (vtkNew < vtkTypeFloat64Array > sself) ; -extern "C" vtkNew < vtkTypeInt16Array > vtkTypeInt16Array_new () ; -extern "C" void vtkTypeInt16Array_destructor (vtkNew < vtkTypeInt16Array > sself) ; -extern "C" void * vtkTypeInt16Array_get_ptr (vtkNew < vtkTypeInt16Array > sself) ; -extern "C" vtkNew < vtkTypeInt32Array > vtkTypeInt32Array_new () ; -extern "C" void vtkTypeInt32Array_destructor (vtkNew < vtkTypeInt32Array > sself) ; -extern "C" void * vtkTypeInt32Array_get_ptr (vtkNew < vtkTypeInt32Array > sself) ; -extern "C" vtkNew < vtkTypeInt64Array > vtkTypeInt64Array_new () ; -extern "C" void vtkTypeInt64Array_destructor (vtkNew < vtkTypeInt64Array > sself) ; -extern "C" void * vtkTypeInt64Array_get_ptr (vtkNew < vtkTypeInt64Array > sself) ; -extern "C" vtkNew < vtkTypeInt8Array > vtkTypeInt8Array_new () ; -extern "C" void vtkTypeInt8Array_destructor (vtkNew < vtkTypeInt8Array > sself) ; -extern "C" void * vtkTypeInt8Array_get_ptr (vtkNew < vtkTypeInt8Array > sself) ; -extern "C" vtkNew < vtkTypeUInt16Array > vtkTypeUInt16Array_new () ; -extern "C" void vtkTypeUInt16Array_destructor (vtkNew < vtkTypeUInt16Array > sself) ; -extern "C" void * vtkTypeUInt16Array_get_ptr (vtkNew < vtkTypeUInt16Array > sself) ; -extern "C" vtkNew < vtkTypeUInt32Array > vtkTypeUInt32Array_new () ; -extern "C" void vtkTypeUInt32Array_destructor (vtkNew < vtkTypeUInt32Array > sself) ; -extern "C" void * vtkTypeUInt32Array_get_ptr (vtkNew < vtkTypeUInt32Array > sself) ; -extern "C" vtkNew < vtkTypeUInt64Array > vtkTypeUInt64Array_new () ; -extern "C" void vtkTypeUInt64Array_destructor (vtkNew < vtkTypeUInt64Array > sself) ; -extern "C" void * vtkTypeUInt64Array_get_ptr (vtkNew < vtkTypeUInt64Array > sself) ; -extern "C" vtkNew < vtkTypeUInt8Array > vtkTypeUInt8Array_new () ; -extern "C" void vtkTypeUInt8Array_destructor (vtkNew < vtkTypeUInt8Array > sself) ; -extern "C" void * vtkTypeUInt8Array_get_ptr (vtkNew < vtkTypeUInt8Array > sself) ; -extern "C" vtkNew < vtkUnsignedCharArray > vtkUnsignedCharArray_new () ; -extern "C" void vtkUnsignedCharArray_destructor (vtkNew < vtkUnsignedCharArray > sself) ; -extern "C" void * vtkUnsignedCharArray_get_ptr (vtkNew < vtkUnsignedCharArray > sself) ; -extern "C" vtkNew < vtkUnsignedIntArray > vtkUnsignedIntArray_new () ; -extern "C" void vtkUnsignedIntArray_destructor (vtkNew < vtkUnsignedIntArray > sself) ; -extern "C" void * vtkUnsignedIntArray_get_ptr (vtkNew < vtkUnsignedIntArray > sself) ; -extern "C" vtkNew < vtkUnsignedLongArray > vtkUnsignedLongArray_new () ; -extern "C" void vtkUnsignedLongArray_destructor (vtkNew < vtkUnsignedLongArray > sself) ; -extern "C" void * vtkUnsignedLongArray_get_ptr (vtkNew < vtkUnsignedLongArray > sself) ; -extern "C" vtkNew < vtkUnsignedLongLongArray > vtkUnsignedLongLongArray_new () ; -extern "C" void vtkUnsignedLongLongArray_destructor (vtkNew < vtkUnsignedLongLongArray > sself) ; -extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkNew < vtkUnsignedLongLongArray > sself) ; -extern "C" vtkNew < vtkUnsignedShortArray > vtkUnsignedShortArray_new () ; -extern "C" void vtkUnsignedShortArray_destructor (vtkNew < vtkUnsignedShortArray > sself) ; -extern "C" void * vtkUnsignedShortArray_get_ptr (vtkNew < vtkUnsignedShortArray > sself) ; -extern "C" vtkNew < vtkVariantArray > vtkVariantArray_new () ; -extern "C" void vtkVariantArray_destructor (vtkNew < vtkVariantArray > sself) ; -extern "C" void * vtkVariantArray_get_ptr (vtkNew < vtkVariantArray > sself) ; -extern "C" vtkNew < vtkVersion > vtkVersion_new () ; -extern "C" void vtkVersion_destructor (vtkNew < vtkVersion > sself) ; -extern "C" void * vtkVersion_get_ptr (vtkNew < vtkVersion > sself) ; -extern "C" vtkNew < vtkVoidArray > vtkVoidArray_new () ; -extern "C" void vtkVoidArray_destructor (vtkNew < vtkVoidArray > sself) ; -extern "C" void * vtkVoidArray_get_ptr (vtkNew < vtkVoidArray > sself) ; -extern "C" vtkNew < vtkWeakReference > vtkWeakReference_new () ; -extern "C" void vtkWeakReference_destructor (vtkNew < vtkWeakReference > sself) ; -extern "C" void * vtkWeakReference_get_ptr (vtkNew < vtkWeakReference > sself) ; -extern "C" vtkNew < vtkXMLFileOutputWindow > vtkXMLFileOutputWindow_new () ; -extern "C" void vtkXMLFileOutputWindow_destructor (vtkNew < vtkXMLFileOutputWindow > sself) ; -extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkNew < vtkXMLFileOutputWindow > sself) ; +extern "C" vtkAnimationCue * vtkAnimationCue_new () ; +extern "C" void vtkAnimationCue_destructor (vtkAnimationCue * sself) ; +extern "C" void vtk_animation_cue_set_time_mode(vtkAnimationCue* sself, int mode); +extern "C" int vtk_animation_cue_get_time_mode(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_set_time_mode_to_normalized(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_set_start_time(vtkAnimationCue* sself, double _arg); +extern "C" double vtk_animation_cue_get_start_time(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_set_end_time(vtkAnimationCue* sself, double _arg); +extern "C" double vtk_animation_cue_get_end_time(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_tick(vtkAnimationCue* sself, double currenttime, double deltatime, double clocktime); +extern "C" void vtk_animation_cue_initialize(vtkAnimationCue* sself); +extern "C" void vtk_animation_cue_finalize(vtkAnimationCue* sself); +extern "C" double vtk_animation_cue_get_animation_time(vtkAnimationCue* sself); +extern "C" double vtk_animation_cue_get_delta_time(vtkAnimationCue* sself); +extern "C" double vtk_animation_cue_get_clock_time(vtkAnimationCue* sself); +extern "C" vtkArchiver * vtkArchiver_new () ; +extern "C" void vtkArchiver_destructor (vtkArchiver * sself) ; +extern "C" void vtk_archiver_set_archive_name(vtkArchiver* sself, const char* _arg); +extern "C" void vtk_archiver_open_archive(vtkArchiver* sself); +extern "C" void vtk_archiver_close_archive(vtkArchiver* sself); +extern "C" void vtk_archiver_insert_into_archive(vtkArchiver* sself, const char*& relativePath, const char* data, size_t size); +extern "C" bool vtk_archiver_contains(vtkArchiver* sself, const char*& relativePath); +extern "C" vtkBitArray * vtkBitArray_new () ; +extern "C" void vtkBitArray_destructor (vtkBitArray * sself) ; +extern "C" int vtk_bit_array_allocate(vtkBitArray* sself, long long sz, long long ext); +extern "C" void vtk_bit_array_initialize(vtkBitArray* sself); +extern "C" int vtk_bit_array_get_data_type(vtkBitArray* sself); +extern "C" int vtk_bit_array_get_data_type_size(vtkBitArray* sself); +extern "C" void vtk_bit_array_set_number_of_tuples(vtkBitArray* sself, long long number); +extern "C" bool vtk_bit_array_set_number_of_values(vtkBitArray* sself, long long number); +extern "C" void vtk_bit_array_remove_tuple(vtkBitArray* sself, long long id); +extern "C" void vtk_bit_array_set_component(vtkBitArray* sself, long long i, int j, double c); +extern "C" void vtk_bit_array_squeeze(vtkBitArray* sself); +extern "C" int vtk_bit_array_resize(vtkBitArray* sself, long long numTuples); +extern "C" int vtk_bit_array_get_value(vtkBitArray* sself, long long id); +extern "C" void vtk_bit_array_set_value(vtkBitArray* sself, long long id, int value); +extern "C" void vtk_bit_array_insert_value(vtkBitArray* sself, long long id, int i); +extern "C" long long vtk_bit_array_insert_next_value(vtkBitArray* sself, int i); +extern "C" void vtk_bit_array_insert_component(vtkBitArray* sself, long long i, int j, double c); +extern "C" void* vtk_bit_array_write_void_pointer(vtkBitArray* sself, long long id, long long number); +extern "C" void* vtk_bit_array_get_void_pointer(vtkBitArray* sself, long long id); +extern "C" void vtk_bit_array_set_void_array(vtkBitArray* sself, void* array, long long size, int save); +extern "C" void vtk_bit_array_data_changed(vtkBitArray* sself); +extern "C" void vtk_bit_array_clear_lookup(vtkBitArray* sself); +extern "C" vtkBitArrayIterator * vtkBitArrayIterator_new () ; +extern "C" void vtkBitArrayIterator_destructor (vtkBitArrayIterator * sself) ; +extern "C" int vtk_bit_array_iterator_get_value(vtkBitArrayIterator* sself, long long id); +extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkBitArrayIterator* sself); +extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkBitArrayIterator* sself); +extern "C" int vtk_bit_array_iterator_get_number_of_components(vtkBitArrayIterator* sself); +extern "C" int vtk_bit_array_iterator_get_data_type(vtkBitArrayIterator* sself); +extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkBitArrayIterator* sself); +extern "C" void vtk_bit_array_iterator_set_value(vtkBitArrayIterator* sself, long long id, int value); +extern "C" vtkBoxMuellerRandomSequence * vtkBoxMuellerRandomSequence_new () ; +extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkBoxMuellerRandomSequence * sself) ; +extern "C" void vtk_box_mueller_random_sequence_initialize(vtkBoxMuellerRandomSequence* sself, unsigned int seed); +extern "C" double vtk_box_mueller_random_sequence_get_value(vtkBoxMuellerRandomSequence* sself); +extern "C" void vtk_box_mueller_random_sequence_next(vtkBoxMuellerRandomSequence* sself); +extern "C" vtkByteSwap * vtkByteSwap_new () ; +extern "C" void vtkByteSwap_destructor (vtkByteSwap * sself) ; +extern "C" void vtk_byte_swap_swap_2_le(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_4_le(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_8_le(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_2_le_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_4_le_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_8_le_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_2_be(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_4_be(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_8_be(vtkByteSwap* sself, void* p); +extern "C" void vtk_byte_swap_swap_2_be_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_4_be_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_8_be_range(vtkByteSwap* sself, void* p, size_t num); +extern "C" void vtk_byte_swap_swap_void_range(vtkByteSwap* sself, void* buffer, size_t numWords, size_t wordSize); +extern "C" vtkCallbackCommand * vtkCallbackCommand_new () ; +extern "C" void vtkCallbackCommand_destructor (vtkCallbackCommand * sself) ; +extern "C" void vtk_callback_command_set_client_data(vtkCallbackCommand* sself, void* cd); +extern "C" void* vtk_callback_command_get_client_data(vtkCallbackCommand* sself); +extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkCallbackCommand* sself, int f); +extern "C" int vtk_callback_command_get_abort_flag_on_execute(vtkCallbackCommand* sself); +extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkCallbackCommand* sself); +extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkCallbackCommand* sself); +extern "C" vtkCharArray * vtkCharArray_new () ; +extern "C" void vtkCharArray_destructor (vtkCharArray * sself) ; +extern "C" int vtk_char_array_get_data_type(vtkCharArray* sself); +extern "C" void vtk_char_array_set_typed_tuple(vtkCharArray* sself, long long i, const char* tuple); +extern "C" void vtk_char_array_insert_typed_tuple(vtkCharArray* sself, long long i, const char* tuple); +extern "C" long long vtk_char_array_insert_next_typed_tuple(vtkCharArray* sself, const char* tuple); +extern "C" char vtk_char_array_get_value(vtkCharArray* sself, long long id); +extern "C" void vtk_char_array_set_value(vtkCharArray* sself, long long id, char value); +extern "C" bool vtk_char_array_set_number_of_values(vtkCharArray* sself, long long number); +extern "C" void vtk_char_array_insert_value(vtkCharArray* sself, long long id, char f); +extern "C" long long vtk_char_array_insert_next_value(vtkCharArray* sself, char f); +extern "C" char vtk_char_array_get_data_type_value_min(vtkCharArray* sself); +extern "C" char vtk_char_array_get_data_type_value_max(vtkCharArray* sself); +extern "C" vtkCollection * vtkCollection_new () ; +extern "C" void vtkCollection_destructor (vtkCollection * sself) ; +extern "C" void vtk_collection_remove_item(vtkCollection* sself, int i); +extern "C" void vtk_collection_remove_all_items(vtkCollection* sself); +extern "C" int vtk_collection_get_number_of_items(vtkCollection* sself); +extern "C" void vtk_collection_init_traversal(vtkCollection* sself); +extern "C" vtkCollectionIterator * vtkCollectionIterator_new () ; +extern "C" void vtkCollectionIterator_destructor (vtkCollectionIterator * sself) ; +extern "C" void vtk_collection_iterator_init_traversal(vtkCollectionIterator* sself); +extern "C" void vtk_collection_iterator_go_to_first_item(vtkCollectionIterator* sself); +extern "C" void vtk_collection_iterator_go_to_next_item(vtkCollectionIterator* sself); +extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkCollectionIterator* sself); +extern "C" vtkCriticalSection * vtkCriticalSection_new () ; +extern "C" void vtkCriticalSection_destructor (vtkCriticalSection * sself) ; +extern "C" void vtk_critical_section_lock(vtkCriticalSection* sself); +extern "C" void vtk_critical_section_unlock(vtkCriticalSection* sself); +extern "C" vtkDataArrayCollection * vtkDataArrayCollection_new () ; +extern "C" void vtkDataArrayCollection_destructor (vtkDataArrayCollection * sself) ; +extern "C" int vtk_data_array_collection_get_number_of_items(vtkDataArrayCollection* sself); +extern "C" vtkDataArrayCollectionIterator * vtkDataArrayCollectionIterator_new () ; +extern "C" void vtkDataArrayCollectionIterator_destructor (vtkDataArrayCollectionIterator * sself) ; +extern "C" vtkDataArraySelection * vtkDataArraySelection_new () ; +extern "C" void vtkDataArraySelection_destructor (vtkDataArraySelection * sself) ; +extern "C" void vtk_data_array_selection_enable_array(vtkDataArraySelection* sself, const char* name); +extern "C" void vtk_data_array_selection_disable_array(vtkDataArraySelection* sself, const char* name); +extern "C" int vtk_data_array_selection_array_is_enabled(vtkDataArraySelection* sself, const char* name); +extern "C" int vtk_data_array_selection_array_exists(vtkDataArraySelection* sself, const char* name); +extern "C" void vtk_data_array_selection_enable_all_arrays(vtkDataArraySelection* sself); +extern "C" void vtk_data_array_selection_disable_all_arrays(vtkDataArraySelection* sself); +extern "C" int vtk_data_array_selection_get_number_of_arrays(vtkDataArraySelection* sself); +extern "C" int vtk_data_array_selection_get_number_of_arrays_enabled(vtkDataArraySelection* sself); +extern "C" const char* vtk_data_array_selection_get_array_name(vtkDataArraySelection* sself, int index); +extern "C" int vtk_data_array_selection_get_array_index(vtkDataArraySelection* sself, const char* name); +extern "C" int vtk_data_array_selection_get_enabled_array_index(vtkDataArraySelection* sself, const char* name); +extern "C" int vtk_data_array_selection_get_array_setting(vtkDataArraySelection* sself, int index); +extern "C" void vtk_data_array_selection_set_array_setting(vtkDataArraySelection* sself, const char* name, int setting); +extern "C" void vtk_data_array_selection_remove_all_arrays(vtkDataArraySelection* sself); +extern "C" int vtk_data_array_selection_add_array(vtkDataArraySelection* sself, const char* name, bool state); +extern "C" void vtk_data_array_selection_remove_array_by_index(vtkDataArraySelection* sself, int index); +extern "C" void vtk_data_array_selection_remove_array_by_name(vtkDataArraySelection* sself, const char* name); +extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkDataArraySelection* sself, int _arg); +extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkDataArraySelection* sself); +extern "C" vtkDebugLeaks * vtkDebugLeaks_new () ; +extern "C" void vtkDebugLeaks_destructor (vtkDebugLeaks * sself) ; +extern "C" int vtk_debug_leaks_print_current_leaks(vtkDebugLeaks* sself); +extern "C" int vtk_debug_leaks_get_exit_error(vtkDebugLeaks* sself); +extern "C" void vtk_debug_leaks_set_exit_error(vtkDebugLeaks* sself, int p0); +extern "C" vtkDoubleArray * vtkDoubleArray_new () ; +extern "C" void vtkDoubleArray_destructor (vtkDoubleArray * sself) ; +extern "C" int vtk_double_array_get_data_type(vtkDoubleArray* sself); +extern "C" double vtk_double_array_get_value(vtkDoubleArray* sself, long long id); +extern "C" void vtk_double_array_set_value(vtkDoubleArray* sself, long long id, double value); +extern "C" bool vtk_double_array_set_number_of_values(vtkDoubleArray* sself, long long number); +extern "C" void vtk_double_array_insert_value(vtkDoubleArray* sself, long long id, double f); +extern "C" long long vtk_double_array_insert_next_value(vtkDoubleArray* sself, double f); +extern "C" double vtk_double_array_get_data_type_value_min(vtkDoubleArray* sself); +extern "C" double vtk_double_array_get_data_type_value_max(vtkDoubleArray* sself); +extern "C" vtkDynamicLoader * vtkDynamicLoader_new () ; +extern "C" void vtkDynamicLoader_destructor (vtkDynamicLoader * sself) ; +extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkDynamicLoader* sself); +extern "C" const char* vtk_dynamic_loader_lib_extension(vtkDynamicLoader* sself); +extern "C" const char* vtk_dynamic_loader_last_error(vtkDynamicLoader* sself); +extern "C" vtkEventDataDevice3D * vtkEventDataDevice3D_new () ; +extern "C" void vtkEventDataDevice3D_destructor (vtkEventDataDevice3D * sself) ; +extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkEventDataDevice3D* sself, double x, double y); +extern "C" vtkEventDataForDevice * vtkEventDataForDevice_new () ; +extern "C" void vtkEventDataForDevice_destructor (vtkEventDataForDevice * sself) ; +extern "C" vtkEventForwarderCommand * vtkEventForwarderCommand_new () ; +extern "C" void vtkEventForwarderCommand_destructor (vtkEventForwarderCommand * sself) ; +extern "C" void* vtk_event_forwarder_command_get_target(vtkEventForwarderCommand* sself); +extern "C" vtkFileOutputWindow * vtkFileOutputWindow_new () ; +extern "C" void vtkFileOutputWindow_destructor (vtkFileOutputWindow * sself) ; +extern "C" void vtk_file_output_window_display_text(vtkFileOutputWindow* sself, const char* p0); +extern "C" void vtk_file_output_window_set_file_name(vtkFileOutputWindow* sself, const char* _arg); +extern "C" void vtk_file_output_window_set_flush(vtkFileOutputWindow* sself, int _arg); +extern "C" int vtk_file_output_window_get_flush(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_flush_on(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_flush_off(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_set_append(vtkFileOutputWindow* sself, int _arg); +extern "C" int vtk_file_output_window_get_append(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_append_on(vtkFileOutputWindow* sself); +extern "C" void vtk_file_output_window_append_off(vtkFileOutputWindow* sself); +extern "C" vtkFloatArray * vtkFloatArray_new () ; +extern "C" void vtkFloatArray_destructor (vtkFloatArray * sself) ; +extern "C" int vtk_float_array_get_data_type(vtkFloatArray* sself); +extern "C" float vtk_float_array_get_value(vtkFloatArray* sself, long long id); +extern "C" void vtk_float_array_set_value(vtkFloatArray* sself, long long id, float value); +extern "C" bool vtk_float_array_set_number_of_values(vtkFloatArray* sself, long long number); +extern "C" void vtk_float_array_insert_value(vtkFloatArray* sself, long long id, float f); +extern "C" long long vtk_float_array_insert_next_value(vtkFloatArray* sself, float f); +extern "C" float vtk_float_array_get_data_type_value_min(vtkFloatArray* sself); +extern "C" float vtk_float_array_get_data_type_value_max(vtkFloatArray* sself); +extern "C" vtkGarbageCollector * vtkGarbageCollector_new () ; +extern "C" void vtkGarbageCollector_destructor (vtkGarbageCollector * sself) ; +extern "C" void vtk_garbage_collector_collect(vtkGarbageCollector* sself); +extern "C" void vtk_garbage_collector_deferred_collection_push(vtkGarbageCollector* sself); +extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkGarbageCollector* sself); +extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkGarbageCollector* sself, bool flag); +extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkGarbageCollector* sself); +extern "C" vtkIdList * vtkIdList_new () ; +extern "C" void vtkIdList_destructor (vtkIdList * sself) ; +extern "C" void vtk_id_list_initialize(vtkIdList* sself); +extern "C" int vtk_id_list_allocate(vtkIdList* sself, const long long sz, const int strategy); +extern "C" long long vtk_id_list_get_number_of_ids(vtkIdList* sself); +extern "C" long long vtk_id_list_get_id(vtkIdList* sself, const long long i); +extern "C" long long vtk_id_list_find_id_location(vtkIdList* sself, const long long id); +extern "C" void vtk_id_list_set_number_of_ids(vtkIdList* sself, const long long number); +extern "C" void vtk_id_list_set_id(vtkIdList* sself, const long long i, const long long vtkid); +extern "C" void vtk_id_list_insert_id(vtkIdList* sself, const long long i, const long long vtkid); +extern "C" long long vtk_id_list_insert_next_id(vtkIdList* sself, const long long vtkid); +extern "C" long long vtk_id_list_insert_unique_id(vtkIdList* sself, const long long vtkid); +extern "C" void vtk_id_list_sort(vtkIdList* sself); +extern "C" void vtk_id_list_fill(vtkIdList* sself, long long value); +extern "C" void vtk_id_list_reset(vtkIdList* sself); +extern "C" void vtk_id_list_squeeze(vtkIdList* sself); +extern "C" void vtk_id_list_delete_id(vtkIdList* sself, long long vtkid); +extern "C" long long vtk_id_list_is_id(vtkIdList* sself, long long vtkid); +extern "C" vtkIdListCollection * vtkIdListCollection_new () ; +extern "C" void vtkIdListCollection_destructor (vtkIdListCollection * sself) ; +extern "C" int vtk_id_list_collection_get_number_of_items(vtkIdListCollection* sself); +extern "C" vtkIdTypeArray * vtkIdTypeArray_new () ; +extern "C" void vtkIdTypeArray_destructor (vtkIdTypeArray * sself) ; +extern "C" int vtk_id_type_array_get_data_type(vtkIdTypeArray* sself); +extern "C" long long vtk_id_type_array_get_value(vtkIdTypeArray* sself, long long id); +extern "C" void vtk_id_type_array_set_value(vtkIdTypeArray* sself, long long id, long long value); +extern "C" bool vtk_id_type_array_set_number_of_values(vtkIdTypeArray* sself, long long number); +extern "C" void vtk_id_type_array_insert_value(vtkIdTypeArray* sself, long long id, long long f); +extern "C" long long vtk_id_type_array_insert_next_value(vtkIdTypeArray* sself, long long f); +extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkIdTypeArray* sself); +extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkIdTypeArray* sself); +extern "C" vtkInformation * vtkInformation_new () ; +extern "C" void vtkInformation_destructor (vtkInformation * sself) ; +extern "C" void vtk_information_modified(vtkInformation* sself); +extern "C" void vtk_information_clear(vtkInformation* sself); +extern "C" int vtk_information_get_number_of_keys(vtkInformation* sself); +extern "C" vtkInformationIterator * vtkInformationIterator_new () ; +extern "C" void vtkInformationIterator_destructor (vtkInformationIterator * sself) ; +extern "C" void vtk_information_iterator_init_traversal(vtkInformationIterator* sself); +extern "C" void vtk_information_iterator_go_to_first_item(vtkInformationIterator* sself); +extern "C" void vtk_information_iterator_go_to_next_item(vtkInformationIterator* sself); +extern "C" int vtk_information_iterator_is_done_with_traversal(vtkInformationIterator* sself); +extern "C" vtkInformationKeyLookup * vtkInformationKeyLookup_new () ; +extern "C" void vtkInformationKeyLookup_destructor (vtkInformationKeyLookup * sself) ; +extern "C" vtkInformationVector * vtkInformationVector_new () ; +extern "C" void vtkInformationVector_destructor (vtkInformationVector * sself) ; +extern "C" int vtk_information_vector_get_number_of_information_objects(vtkInformationVector* sself); +extern "C" void vtk_information_vector_set_number_of_information_objects(vtkInformationVector* sself, int n); +extern "C" vtkIntArray * vtkIntArray_new () ; +extern "C" void vtkIntArray_destructor (vtkIntArray * sself) ; +extern "C" int vtk_int_array_get_data_type(vtkIntArray* sself); +extern "C" int vtk_int_array_get_value(vtkIntArray* sself, long long id); +extern "C" void vtk_int_array_set_value(vtkIntArray* sself, long long id, int value); +extern "C" bool vtk_int_array_set_number_of_values(vtkIntArray* sself, long long number); +extern "C" void vtk_int_array_insert_value(vtkIntArray* sself, long long id, int f); +extern "C" long long vtk_int_array_insert_next_value(vtkIntArray* sself, int f); +extern "C" int vtk_int_array_get_data_type_value_min(vtkIntArray* sself); +extern "C" int vtk_int_array_get_data_type_value_max(vtkIntArray* sself); +extern "C" vtkLongArray * vtkLongArray_new () ; +extern "C" void vtkLongArray_destructor (vtkLongArray * sself) ; +extern "C" int vtk_long_array_get_data_type(vtkLongArray* sself); +extern "C" long vtk_long_array_get_value(vtkLongArray* sself, long long id); +extern "C" void vtk_long_array_set_value(vtkLongArray* sself, long long id, long value); +extern "C" bool vtk_long_array_set_number_of_values(vtkLongArray* sself, long long number); +extern "C" void vtk_long_array_insert_value(vtkLongArray* sself, long long id, long f); +extern "C" long long vtk_long_array_insert_next_value(vtkLongArray* sself, long f); +extern "C" long vtk_long_array_get_data_type_value_min(vtkLongArray* sself); +extern "C" long vtk_long_array_get_data_type_value_max(vtkLongArray* sself); +extern "C" vtkLongLongArray * vtkLongLongArray_new () ; +extern "C" void vtkLongLongArray_destructor (vtkLongLongArray * sself) ; +extern "C" int vtk_long_long_array_get_data_type(vtkLongLongArray* sself); +extern "C" long long vtk_long_long_array_get_value(vtkLongLongArray* sself, long long id); +extern "C" void vtk_long_long_array_set_value(vtkLongLongArray* sself, long long id, long long value); +extern "C" bool vtk_long_long_array_set_number_of_values(vtkLongLongArray* sself, long long number); +extern "C" void vtk_long_long_array_insert_value(vtkLongLongArray* sself, long long id, long long f); +extern "C" long long vtk_long_long_array_insert_next_value(vtkLongLongArray* sself, long long f); +extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkLongLongArray* sself); +extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkLongLongArray* sself); +extern "C" vtkLookupTable * vtkLookupTable_new () ; +extern "C" void vtkLookupTable_destructor (vtkLookupTable * sself) ; +extern "C" int vtk_lookup_table_is_opaque(vtkLookupTable* sself); +extern "C" int vtk_lookup_table_allocate(vtkLookupTable* sself, int sz, int ext); +extern "C" void vtk_lookup_table_build(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_force_build(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_build_special_colors(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_ramp(vtkLookupTable* sself, int _arg); +extern "C" void vtk_lookup_table_set_ramp_to_linear(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_ramp_to_s_curve(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_ramp_to_sqrt(vtkLookupTable* sself); +extern "C" int vtk_lookup_table_get_ramp(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_scale(vtkLookupTable* sself, int scale); +extern "C" void vtk_lookup_table_set_scale_to_linear(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_scale_to_log_10(vtkLookupTable* sself); +extern "C" int vtk_lookup_table_get_scale(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_table_range(vtkLookupTable* sself, double min, double max); +extern "C" void vtk_lookup_table_set_hue_range(vtkLookupTable* sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_saturation_range(vtkLookupTable* sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_value_range(vtkLookupTable* sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_alpha_range(vtkLookupTable* sself, double _arg1, double _arg2); +extern "C" void vtk_lookup_table_set_nan_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_below_range_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_use_below_range_color(vtkLookupTable* sself, int _arg); +extern "C" int vtk_lookup_table_get_use_below_range_color(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_use_below_range_color_on(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_use_below_range_color_off(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_above_range_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4); +extern "C" void vtk_lookup_table_set_use_above_range_color(vtkLookupTable* sself, int _arg); +extern "C" int vtk_lookup_table_get_use_above_range_color(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_use_above_range_color_on(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_use_above_range_color_off(vtkLookupTable* sself); +extern "C" double vtk_lookup_table_get_opacity(vtkLookupTable* sself, double v); +extern "C" long long vtk_lookup_table_get_index(vtkLookupTable* sself, double v); +extern "C" void vtk_lookup_table_set_number_of_table_values(vtkLookupTable* sself, long long number); +extern "C" long long vtk_lookup_table_get_number_of_table_values(vtkLookupTable* sself); +extern "C" void vtk_lookup_table_set_table_value(vtkLookupTable* sself, long long indx, double r, double g, double b, double a); +extern "C" void vtk_lookup_table_set_number_of_colors(vtkLookupTable* sself, long long _arg); +extern "C" long long vtk_lookup_table_get_number_of_colors_min_value(vtkLookupTable* sself); +extern "C" long long vtk_lookup_table_get_number_of_colors_max_value(vtkLookupTable* sself); +extern "C" long long vtk_lookup_table_get_number_of_colors(vtkLookupTable* sself); +extern "C" int vtk_lookup_table_using_log_scale(vtkLookupTable* sself); +extern "C" vtkMath * vtkMath_new () ; +extern "C" void vtkMath_destructor (vtkMath * sself) ; +extern "C" double vtk_math_pi(vtkMath* sself); +extern "C" float vtk_math_radians_from_degrees(vtkMath* sself, float degrees); +extern "C" float vtk_math_degrees_from_radians(vtkMath* sself, float radians); +extern "C" int vtk_math_round(vtkMath* sself, float f); +extern "C" int vtk_math_floor(vtkMath* sself, double x); +extern "C" int vtk_math_ceil(vtkMath* sself, double x); +extern "C" int vtk_math_ceil_log_2(vtkMath* sself, unsigned long long x); +extern "C" bool vtk_math_is_power_of_two(vtkMath* sself, unsigned long long x); +extern "C" int vtk_math_nearest_power_of_two(vtkMath* sself, int x); +extern "C" long long vtk_math_factorial(vtkMath* sself, int N); +extern "C" long long vtk_math_binomial(vtkMath* sself, int m, int n); +extern "C" void vtk_math_random_seed(vtkMath* sself, int s); +extern "C" int vtk_math_get_seed(vtkMath* sself); +extern "C" double vtk_math_random(vtkMath* sself); +extern "C" double vtk_math_gaussian(vtkMath* sself); +extern "C" double vtk_math_gaussian_amplitude(vtkMath* sself, const double variance, const double distanceFromMean); +extern "C" double vtk_math_gaussian_weight(vtkMath* sself, const double variance, const double distanceFromMean); +extern "C" double vtk_math_determinant_2_x_2(vtkMath* sself, double a, double b, double c, double d); +extern "C" double vtk_math_determinant_3_x_3(vtkMath* sself, double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3); +extern "C" int vtk_math_solve_linear_system_gepp_2_x_2(vtkMath* sself, double a00, double a01, double a10, double a11, double b0, double b1, double& x0, double& x1); +extern "C" int vtk_math_get_scalar_type_fitting_range(vtkMath* sself, double range_min, double range_max, double scale, double shift); +extern "C" double vtk_math_inf(vtkMath* sself); +extern "C" double vtk_math_neg_inf(vtkMath* sself); +extern "C" double vtk_math_nan(vtkMath* sself); +extern "C" int vtk_math_is_inf(vtkMath* sself, double x); +extern "C" int vtk_math_is_nan(vtkMath* sself, double x); +extern "C" bool vtk_math_is_finite(vtkMath* sself, double x); +extern "C" vtkMersenneTwister * vtkMersenneTwister_new () ; +extern "C" void vtkMersenneTwister_destructor (vtkMersenneTwister * sself) ; +extern "C" void vtk_mersenne_twister_initialize(vtkMersenneTwister* sself, unsigned int seed); +extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkMersenneTwister* sself, unsigned int seed, int p); +extern "C" void vtk_mersenne_twister_initialize_sequence(vtkMersenneTwister* sself, unsigned int id, unsigned int seed, int p); +extern "C" double vtk_mersenne_twister_get_value(vtkMersenneTwister* sself, unsigned int id); +extern "C" void vtk_mersenne_twister_next(vtkMersenneTwister* sself, unsigned int id); +extern "C" vtkMinimalStandardRandomSequence * vtkMinimalStandardRandomSequence_new () ; +extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkMinimalStandardRandomSequence * sself) ; +extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkMinimalStandardRandomSequence* sself, unsigned int seed); +extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkMinimalStandardRandomSequence* sself, int value); +extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkMinimalStandardRandomSequence* sself, int value); +extern "C" int vtk_minimal_standard_random_sequence_get_seed(vtkMinimalStandardRandomSequence* sself); +extern "C" double vtk_minimal_standard_random_sequence_get_value(vtkMinimalStandardRandomSequence* sself); +extern "C" void vtk_minimal_standard_random_sequence_next(vtkMinimalStandardRandomSequence* sself); +extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax); +extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax); +extern "C" vtkMultiThreader * vtkMultiThreader_new () ; +extern "C" void vtkMultiThreader_destructor (vtkMultiThreader * sself) ; +extern "C" void vtk_multi_threader_set_number_of_threads(vtkMultiThreader* sself, int _arg); +extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkMultiThreader* sself); +extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkMultiThreader* sself); +extern "C" int vtk_multi_threader_get_number_of_threads(vtkMultiThreader* sself); +extern "C" int vtk_multi_threader_get_global_static_maximum_number_of_threads(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_set_global_maximum_number_of_threads(vtkMultiThreader* sself, int val); +extern "C" int vtk_multi_threader_get_global_maximum_number_of_threads(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_set_global_default_number_of_threads(vtkMultiThreader* sself, int val); +extern "C" int vtk_multi_threader_get_global_default_number_of_threads(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_single_method_execute(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_multiple_method_execute(vtkMultiThreader* sself); +extern "C" void vtk_multi_threader_terminate_thread(vtkMultiThreader* sself, int threadId); +extern "C" int vtk_multi_threader_is_thread_active(vtkMultiThreader* sself, int threadId); +extern "C" vtkObject * vtkObject_new () ; +extern "C" void vtkObject_destructor (vtkObject * sself) ; +extern "C" int vtk_object_is_type_of(vtkObject* sself, const char* type); +extern "C" int vtk_object_is_a(vtkObject* sself, const char* type); +extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkObject* sself, const char* type); +extern "C" long long vtk_object_get_number_of_generations_from_base(vtkObject* sself, const char* type); +extern "C" void vtk_object_debug_on(vtkObject* sself); +extern "C" void vtk_object_debug_off(vtkObject* sself); +extern "C" bool vtk_object_get_debug(vtkObject* sself); +extern "C" void vtk_object_set_debug(vtkObject* sself, bool debugFlag); +extern "C" void vtk_object_break_on_error(vtkObject* sself); +extern "C" void vtk_object_modified(vtkObject* sself); +extern "C" unsigned long vtk_object_get_m_time(vtkObject* sself); +extern "C" void vtk_object_set_global_warning_display(vtkObject* sself, int val); +extern "C" void vtk_object_global_warning_display_on(vtkObject* sself); +extern "C" void vtk_object_global_warning_display_off(vtkObject* sself); +extern "C" int vtk_object_get_global_warning_display(vtkObject* sself); +extern "C" void vtk_object_remove_all_observers(vtkObject* sself); +extern "C" int vtk_object_invoke_event(vtkObject* sself, unsigned long event, void* callData); +extern "C" vtkObjectFactoryCollection * vtkObjectFactoryCollection_new () ; +extern "C" void vtkObjectFactoryCollection_destructor (vtkObjectFactoryCollection * sself) ; +extern "C" vtkOldStyleCallbackCommand * vtkOldStyleCallbackCommand_new () ; +extern "C" void vtkOldStyleCallbackCommand_destructor (vtkOldStyleCallbackCommand * sself) ; +extern "C" void vtk_old_style_callback_command_set_client_data(vtkOldStyleCallbackCommand* sself, void* cd); +extern "C" vtkOutputWindow * vtkOutputWindow_new () ; +extern "C" void vtkOutputWindow_destructor (vtkOutputWindow * sself) ; +extern "C" void vtk_output_window_display_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_display_error_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_display_warning_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_display_generic_warning_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_display_debug_text(vtkOutputWindow* sself, const char* p0); +extern "C" void vtk_output_window_prompt_user_on(vtkOutputWindow* sself); +extern "C" void vtk_output_window_prompt_user_off(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_prompt_user(vtkOutputWindow* sself, bool _arg); +extern "C" void vtk_output_window_set_use_std_error_for_all_messages(vtkOutputWindow* sself, bool p0); +extern "C" bool vtk_output_window_get_use_std_error_for_all_messages(vtkOutputWindow* sself); +extern "C" void vtk_output_window_use_std_error_for_all_messages_on(vtkOutputWindow* sself); +extern "C" void vtk_output_window_use_std_error_for_all_messages_off(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode(vtkOutputWindow* sself, int _arg); +extern "C" int vtk_output_window_get_display_mode_min_value(vtkOutputWindow* sself); +extern "C" int vtk_output_window_get_display_mode_max_value(vtkOutputWindow* sself); +extern "C" int vtk_output_window_get_display_mode(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode_to_default(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode_to_never(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode_to_always(vtkOutputWindow* sself); +extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkOutputWindow* sself); +extern "C" vtkOverrideInformationCollection * vtkOverrideInformationCollection_new () ; +extern "C" void vtkOverrideInformationCollection_destructor (vtkOverrideInformationCollection * sself) ; +extern "C" vtkPoints * vtkPoints_new () ; +extern "C" void vtkPoints_destructor (vtkPoints * sself) ; +extern "C" int vtk_points_allocate(vtkPoints* sself, long long sz, long long ext); +extern "C" void vtk_points_initialize(vtkPoints* sself); +extern "C" int vtk_points_get_data_type(vtkPoints* sself); +extern "C" void vtk_points_set_data_type(vtkPoints* sself, int dataType); +extern "C" void vtk_points_set_data_type_to_bit(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_char(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_unsigned_char(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_short(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_unsigned_short(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_int(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_unsigned_int(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_long(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_unsigned_long(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_float(vtkPoints* sself); +extern "C" void vtk_points_set_data_type_to_double(vtkPoints* sself); +extern "C" void* vtk_points_get_void_pointer(vtkPoints* sself, const int id); +extern "C" void vtk_points_squeeze(vtkPoints* sself); +extern "C" void vtk_points_reset(vtkPoints* sself); +extern "C" unsigned long vtk_points_get_actual_memory_size(vtkPoints* sself); +extern "C" long long vtk_points_get_number_of_points(vtkPoints* sself); +extern "C" void vtk_points_set_point(vtkPoints* sself, long long id, double x, double y, double z); +extern "C" void vtk_points_insert_point(vtkPoints* sself, long long id, double x, double y, double z); +extern "C" long long vtk_points_insert_next_point(vtkPoints* sself, double x, double y, double z); +extern "C" void vtk_points_set_number_of_points(vtkPoints* sself, long long numPoints); +extern "C" int vtk_points_resize(vtkPoints* sself, long long numPoints); +extern "C" void vtk_points_compute_bounds(vtkPoints* sself); +extern "C" unsigned long vtk_points_get_m_time(vtkPoints* sself); +extern "C" void vtk_points_modified(vtkPoints* sself); +extern "C" vtkPoints2D * vtkPoints2D_new () ; +extern "C" void vtkPoints2D_destructor (vtkPoints2D * sself) ; +extern "C" int vtk_points_2_d_allocate(vtkPoints2D* sself, long long sz, long long ext); +extern "C" void vtk_points_2_d_initialize(vtkPoints2D* sself); +extern "C" int vtk_points_2_d_get_data_type(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type(vtkPoints2D* sself, int dataType); +extern "C" void vtk_points_2_d_set_data_type_to_bit(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_char(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_char(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_short(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_short(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_int(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_int(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_long(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_long(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_float(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_data_type_to_double(vtkPoints2D* sself); +extern "C" void* vtk_points_2_d_get_void_pointer(vtkPoints2D* sself, const int id); +extern "C" void vtk_points_2_d_squeeze(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_reset(vtkPoints2D* sself); +extern "C" unsigned long vtk_points_2_d_get_actual_memory_size(vtkPoints2D* sself); +extern "C" long long vtk_points_2_d_get_number_of_points(vtkPoints2D* sself); +extern "C" void vtk_points_2_d_set_point(vtkPoints2D* sself, long long id, double x, double y); +extern "C" void vtk_points_2_d_insert_point(vtkPoints2D* sself, long long id, double x, double y); +extern "C" long long vtk_points_2_d_insert_next_point(vtkPoints2D* sself, double x, double y); +extern "C" void vtk_points_2_d_remove_point(vtkPoints2D* sself, long long id); +extern "C" void vtk_points_2_d_set_number_of_points(vtkPoints2D* sself, long long numPoints); +extern "C" int vtk_points_2_d_resize(vtkPoints2D* sself, long long numPoints); +extern "C" void vtk_points_2_d_compute_bounds(vtkPoints2D* sself); +extern "C" vtkPriorityQueue * vtkPriorityQueue_new () ; +extern "C" void vtkPriorityQueue_destructor (vtkPriorityQueue * sself) ; +extern "C" void vtk_priority_queue_allocate(vtkPriorityQueue* sself, long long sz, long long ext); +extern "C" void vtk_priority_queue_insert(vtkPriorityQueue* sself, double priority, long long id); +extern "C" long long vtk_priority_queue_pop(vtkPriorityQueue* sself, long long location, double& priority); +extern "C" long long vtk_priority_queue_peek(vtkPriorityQueue* sself, long long location, double& priority); +extern "C" double vtk_priority_queue_delete_id(vtkPriorityQueue* sself, long long id); +extern "C" double vtk_priority_queue_get_priority(vtkPriorityQueue* sself, long long id); +extern "C" long long vtk_priority_queue_get_number_of_items(vtkPriorityQueue* sself); +extern "C" void vtk_priority_queue_reset(vtkPriorityQueue* sself); +extern "C" vtkRandomPool * vtkRandomPool_new () ; +extern "C" void vtkRandomPool_destructor (vtkRandomPool * sself) ; +extern "C" void vtk_random_pool_set_size(vtkRandomPool* sself, long long _arg); +extern "C" long long vtk_random_pool_get_size_min_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_size_max_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_size(vtkRandomPool* sself); +extern "C" void vtk_random_pool_set_number_of_components(vtkRandomPool* sself, long long _arg); +extern "C" long long vtk_random_pool_get_number_of_components_min_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_number_of_components_max_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_number_of_components(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_total_size(vtkRandomPool* sself); +extern "C" double vtk_random_pool_get_value(vtkRandomPool* sself, long long i); +extern "C" void vtk_random_pool_set_chunk_size(vtkRandomPool* sself, long long _arg); +extern "C" long long vtk_random_pool_get_chunk_size_min_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkRandomPool* sself); +extern "C" long long vtk_random_pool_get_chunk_size(vtkRandomPool* sself); +extern "C" vtkReferenceCount * vtkReferenceCount_new () ; +extern "C" void vtkReferenceCount_destructor (vtkReferenceCount * sself) ; +extern "C" vtkScalarsToColors * vtkScalarsToColors_new () ; +extern "C" void vtkScalarsToColors_destructor (vtkScalarsToColors * sself) ; +extern "C" int vtk_scalars_to_colors_is_opaque(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_build(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_range(vtkScalarsToColors* sself, double min, double max); +extern "C" double vtk_scalars_to_colors_get_opacity(vtkScalarsToColors* sself, double v); +extern "C" double vtk_scalars_to_colors_get_luminance(vtkScalarsToColors* sself, double x); +extern "C" void vtk_scalars_to_colors_set_alpha(vtkScalarsToColors* sself, double alpha); +extern "C" double vtk_scalars_to_colors_get_alpha(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode(vtkScalarsToColors* sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_mode(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_magnitude(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_component(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_component(vtkScalarsToColors* sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_component(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_vector_size(vtkScalarsToColors* sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_vector_size(vtkScalarsToColors* sself); +extern "C" int vtk_scalars_to_colors_using_log_scale(vtkScalarsToColors* sself); +extern "C" long long vtk_scalars_to_colors_get_number_of_available_colors(vtkScalarsToColors* sself); +extern "C" long long vtk_scalars_to_colors_get_number_of_annotated_values(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_reset_annotations(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_set_indexed_lookup(vtkScalarsToColors* sself, int _arg); +extern "C" int vtk_scalars_to_colors_get_indexed_lookup(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkScalarsToColors* sself); +extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkScalarsToColors* sself); +extern "C" vtkShortArray * vtkShortArray_new () ; +extern "C" void vtkShortArray_destructor (vtkShortArray * sself) ; +extern "C" int vtk_short_array_get_data_type(vtkShortArray* sself); +extern "C" short vtk_short_array_get_value(vtkShortArray* sself, long long id); +extern "C" void vtk_short_array_set_value(vtkShortArray* sself, long long id, short value); +extern "C" bool vtk_short_array_set_number_of_values(vtkShortArray* sself, long long number); +extern "C" void vtk_short_array_insert_value(vtkShortArray* sself, long long id, short f); +extern "C" long long vtk_short_array_insert_next_value(vtkShortArray* sself, short f); +extern "C" short vtk_short_array_get_data_type_value_min(vtkShortArray* sself); +extern "C" short vtk_short_array_get_data_type_value_max(vtkShortArray* sself); +extern "C" vtkSignedCharArray * vtkSignedCharArray_new () ; +extern "C" void vtkSignedCharArray_destructor (vtkSignedCharArray * sself) ; +extern "C" int vtk_signed_char_array_get_data_type(vtkSignedCharArray* sself); +extern "C" signed char vtk_signed_char_array_get_value(vtkSignedCharArray* sself, long long id); +extern "C" void vtk_signed_char_array_set_value(vtkSignedCharArray* sself, long long id, signed char value); +extern "C" bool vtk_signed_char_array_set_number_of_values(vtkSignedCharArray* sself, long long number); +extern "C" void vtk_signed_char_array_insert_value(vtkSignedCharArray* sself, long long id, signed char f); +extern "C" long long vtk_signed_char_array_insert_next_value(vtkSignedCharArray* sself, signed char f); +extern "C" signed char vtk_signed_char_array_get_data_type_value_min(vtkSignedCharArray* sself); +extern "C" signed char vtk_signed_char_array_get_data_type_value_max(vtkSignedCharArray* sself); +extern "C" vtkSortDataArray * vtkSortDataArray_new () ; +extern "C" void vtkSortDataArray_destructor (vtkSortDataArray * sself) ; +extern "C" vtkStringArray * vtkStringArray_new () ; +extern "C" void vtkStringArray_destructor (vtkStringArray * sself) ; +extern "C" int vtk_string_array_get_data_type(vtkStringArray* sself); +extern "C" int vtk_string_array_is_numeric(vtkStringArray* sself); +extern "C" void vtk_string_array_initialize(vtkStringArray* sself); +extern "C" int vtk_string_array_get_data_type_size(vtkStringArray* sself); +extern "C" void vtk_string_array_squeeze(vtkStringArray* sself); +extern "C" int vtk_string_array_resize(vtkStringArray* sself, long long numTuples); +extern "C" int vtk_string_array_allocate(vtkStringArray* sself, long long sz, long long ext); +extern "C" void vtk_string_array_set_number_of_tuples(vtkStringArray* sself, long long number); +extern "C" long long vtk_string_array_get_number_of_values(vtkStringArray* sself); +extern "C" int vtk_string_array_get_number_of_element_components(vtkStringArray* sself); +extern "C" int vtk_string_array_get_element_component_size(vtkStringArray* sself); +extern "C" void* vtk_string_array_get_void_pointer(vtkStringArray* sself, long long id); +extern "C" void vtk_string_array_set_void_array(vtkStringArray* sself, void* array, long long size, int save); +extern "C" unsigned long vtk_string_array_get_actual_memory_size(vtkStringArray* sself); +extern "C" long long vtk_string_array_get_data_size(vtkStringArray* sself); +extern "C" void vtk_string_array_data_changed(vtkStringArray* sself); +extern "C" void vtk_string_array_data_element_changed(vtkStringArray* sself, long long id); +extern "C" void vtk_string_array_clear_lookup(vtkStringArray* sself); +extern "C" vtkStringOutputWindow * vtkStringOutputWindow_new () ; +extern "C" void vtkStringOutputWindow_destructor (vtkStringOutputWindow * sself) ; +extern "C" void vtk_string_output_window_display_text(vtkStringOutputWindow* sself, const char* p0); +extern "C" vtkTimePointUtility * vtkTimePointUtility_new () ; +extern "C" void vtkTimePointUtility_destructor (vtkTimePointUtility * sself) ; +extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkTimePointUtility* sself, int year, int month, int day); +extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkTimePointUtility* sself, int hour, int minute, int second, int millis); +extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkTimePointUtility* sself, int year, int month, int day, int hour, int minute, int sec, int millis); +extern "C" void vtk_time_point_utility_get_date(vtkTimePointUtility* sself, unsigned long long time, int& year, int& month, int& day); +extern "C" void vtk_time_point_utility_get_time(vtkTimePointUtility* sself, unsigned long long time, int& hour, int& minute, int& second, int& millis); +extern "C" void vtk_time_point_utility_get_date_time(vtkTimePointUtility* sself, unsigned long long time, int& year, int& month, int& day, int& hour, int& minute, int& second, int& millis); +extern "C" int vtk_time_point_utility_get_year(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_month(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_day(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_hour(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_minute(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_second(vtkTimePointUtility* sself, unsigned long long time); +extern "C" int vtk_time_point_utility_get_millisecond(vtkTimePointUtility* sself, unsigned long long time); +extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkTimePointUtility* sself, unsigned long long p0, int format); +extern "C" vtkTypeFloat32Array * vtkTypeFloat32Array_new () ; +extern "C" void vtkTypeFloat32Array_destructor (vtkTypeFloat32Array * sself) ; +extern "C" vtkTypeFloat64Array * vtkTypeFloat64Array_new () ; +extern "C" void vtkTypeFloat64Array_destructor (vtkTypeFloat64Array * sself) ; +extern "C" vtkTypeInt16Array * vtkTypeInt16Array_new () ; +extern "C" void vtkTypeInt16Array_destructor (vtkTypeInt16Array * sself) ; +extern "C" vtkTypeInt32Array * vtkTypeInt32Array_new () ; +extern "C" void vtkTypeInt32Array_destructor (vtkTypeInt32Array * sself) ; +extern "C" vtkTypeInt64Array * vtkTypeInt64Array_new () ; +extern "C" void vtkTypeInt64Array_destructor (vtkTypeInt64Array * sself) ; +extern "C" vtkTypeInt8Array * vtkTypeInt8Array_new () ; +extern "C" void vtkTypeInt8Array_destructor (vtkTypeInt8Array * sself) ; +extern "C" vtkTypeUInt16Array * vtkTypeUInt16Array_new () ; +extern "C" void vtkTypeUInt16Array_destructor (vtkTypeUInt16Array * sself) ; +extern "C" vtkTypeUInt32Array * vtkTypeUInt32Array_new () ; +extern "C" void vtkTypeUInt32Array_destructor (vtkTypeUInt32Array * sself) ; +extern "C" vtkTypeUInt64Array * vtkTypeUInt64Array_new () ; +extern "C" void vtkTypeUInt64Array_destructor (vtkTypeUInt64Array * sself) ; +extern "C" vtkTypeUInt8Array * vtkTypeUInt8Array_new () ; +extern "C" void vtkTypeUInt8Array_destructor (vtkTypeUInt8Array * sself) ; +extern "C" vtkUnicodeStringArray * vtkUnicodeStringArray_new () ; +extern "C" void vtkUnicodeStringArray_destructor (vtkUnicodeStringArray * sself) ; +extern "C" int vtk_unicode_string_array_allocate(vtkUnicodeStringArray* sself, long long sz, long long ext); +extern "C" void vtk_unicode_string_array_initialize(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_get_data_type(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_get_data_type_size(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_get_element_component_size(vtkUnicodeStringArray* sself); +extern "C" void vtk_unicode_string_array_set_number_of_tuples(vtkUnicodeStringArray* sself, long long number); +extern "C" void* vtk_unicode_string_array_get_void_pointer(vtkUnicodeStringArray* sself, long long id); +extern "C" void vtk_unicode_string_array_squeeze(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_resize(vtkUnicodeStringArray* sself, long long numTuples); +extern "C" void vtk_unicode_string_array_set_void_array(vtkUnicodeStringArray* sself, void* array, long long size, int save); +extern "C" unsigned long vtk_unicode_string_array_get_actual_memory_size(vtkUnicodeStringArray* sself); +extern "C" int vtk_unicode_string_array_is_numeric(vtkUnicodeStringArray* sself); +extern "C" void vtk_unicode_string_array_data_changed(vtkUnicodeStringArray* sself); +extern "C" void vtk_unicode_string_array_clear_lookup(vtkUnicodeStringArray* sself); +extern "C" void vtk_unicode_string_array_insert_next_utf_8_value(vtkUnicodeStringArray* sself, const char* p0); +extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkUnicodeStringArray* sself, long long i, const char* p1); +extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkUnicodeStringArray* sself, long long i); +extern "C" vtkUnsignedCharArray * vtkUnsignedCharArray_new () ; +extern "C" void vtkUnsignedCharArray_destructor (vtkUnsignedCharArray * sself) ; +extern "C" int vtk_unsigned_char_array_get_data_type(vtkUnsignedCharArray* sself); +extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkUnsignedCharArray* sself, long long id); +extern "C" void vtk_unsigned_char_array_set_value(vtkUnsignedCharArray* sself, long long id, unsigned char value); +extern "C" bool vtk_unsigned_char_array_set_number_of_values(vtkUnsignedCharArray* sself, long long number); +extern "C" void vtk_unsigned_char_array_insert_value(vtkUnsignedCharArray* sself, long long id, unsigned char f); +extern "C" long long vtk_unsigned_char_array_insert_next_value(vtkUnsignedCharArray* sself, unsigned char f); +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkUnsignedCharArray* sself); +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkUnsignedCharArray* sself); +extern "C" vtkUnsignedIntArray * vtkUnsignedIntArray_new () ; +extern "C" void vtkUnsignedIntArray_destructor (vtkUnsignedIntArray * sself) ; +extern "C" int vtk_unsigned_int_array_get_data_type(vtkUnsignedIntArray* sself); +extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkUnsignedIntArray* sself, long long id); +extern "C" void vtk_unsigned_int_array_set_value(vtkUnsignedIntArray* sself, long long id, unsigned int value); +extern "C" bool vtk_unsigned_int_array_set_number_of_values(vtkUnsignedIntArray* sself, long long number); +extern "C" void vtk_unsigned_int_array_insert_value(vtkUnsignedIntArray* sself, long long id, unsigned int f); +extern "C" long long vtk_unsigned_int_array_insert_next_value(vtkUnsignedIntArray* sself, unsigned int f); +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkUnsignedIntArray* sself); +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkUnsignedIntArray* sself); +extern "C" vtkUnsignedLongArray * vtkUnsignedLongArray_new () ; +extern "C" void vtkUnsignedLongArray_destructor (vtkUnsignedLongArray * sself) ; +extern "C" int vtk_unsigned_long_array_get_data_type(vtkUnsignedLongArray* sself); +extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkUnsignedLongArray* sself, long long id); +extern "C" void vtk_unsigned_long_array_set_value(vtkUnsignedLongArray* sself, long long id, unsigned long value); +extern "C" bool vtk_unsigned_long_array_set_number_of_values(vtkUnsignedLongArray* sself, long long number); +extern "C" void vtk_unsigned_long_array_insert_value(vtkUnsignedLongArray* sself, long long id, unsigned long f); +extern "C" long long vtk_unsigned_long_array_insert_next_value(vtkUnsignedLongArray* sself, unsigned long f); +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkUnsignedLongArray* sself); +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkUnsignedLongArray* sself); +extern "C" vtkUnsignedLongLongArray * vtkUnsignedLongLongArray_new () ; +extern "C" void vtkUnsignedLongLongArray_destructor (vtkUnsignedLongLongArray * sself) ; +extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkUnsignedLongLongArray* sself); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkUnsignedLongLongArray* sself, long long id); +extern "C" void vtk_unsigned_long_long_array_set_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long value); +extern "C" bool vtk_unsigned_long_long_array_set_number_of_values(vtkUnsignedLongLongArray* sself, long long number); +extern "C" void vtk_unsigned_long_long_array_insert_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long f); +extern "C" long long vtk_unsigned_long_long_array_insert_next_value(vtkUnsignedLongLongArray* sself, unsigned long long f); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_min(vtkUnsignedLongLongArray* sself); +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkUnsignedLongLongArray* sself); +extern "C" vtkUnsignedShortArray * vtkUnsignedShortArray_new () ; +extern "C" void vtkUnsignedShortArray_destructor (vtkUnsignedShortArray * sself) ; +extern "C" int vtk_unsigned_short_array_get_data_type(vtkUnsignedShortArray* sself); +extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkUnsignedShortArray* sself, long long id); +extern "C" void vtk_unsigned_short_array_set_value(vtkUnsignedShortArray* sself, long long id, unsigned short value); +extern "C" bool vtk_unsigned_short_array_set_number_of_values(vtkUnsignedShortArray* sself, long long number); +extern "C" void vtk_unsigned_short_array_insert_value(vtkUnsignedShortArray* sself, long long id, unsigned short f); +extern "C" long long vtk_unsigned_short_array_insert_next_value(vtkUnsignedShortArray* sself, unsigned short f); +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkUnsignedShortArray* sself); +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkUnsignedShortArray* sself); +extern "C" vtkVariantArray * vtkVariantArray_new () ; +extern "C" void vtkVariantArray_destructor (vtkVariantArray * sself) ; +extern "C" int vtk_variant_array_allocate(vtkVariantArray* sself, long long sz, long long ext); +extern "C" void vtk_variant_array_initialize(vtkVariantArray* sself); +extern "C" int vtk_variant_array_get_data_type(vtkVariantArray* sself); +extern "C" int vtk_variant_array_get_data_type_size(vtkVariantArray* sself); +extern "C" int vtk_variant_array_get_element_component_size(vtkVariantArray* sself); +extern "C" void vtk_variant_array_set_number_of_tuples(vtkVariantArray* sself, long long number); +extern "C" void* vtk_variant_array_get_void_pointer(vtkVariantArray* sself, long long id); +extern "C" void vtk_variant_array_squeeze(vtkVariantArray* sself); +extern "C" int vtk_variant_array_resize(vtkVariantArray* sself, long long numTuples); +extern "C" void vtk_variant_array_set_void_array(vtkVariantArray* sself, void* arr, long long size, int save); +extern "C" unsigned long vtk_variant_array_get_actual_memory_size(vtkVariantArray* sself); +extern "C" int vtk_variant_array_is_numeric(vtkVariantArray* sself); +extern "C" long long vtk_variant_array_get_number_of_values(vtkVariantArray* sself); +extern "C" void vtk_variant_array_data_changed(vtkVariantArray* sself); +extern "C" void vtk_variant_array_data_element_changed(vtkVariantArray* sself, long long id); +extern "C" void vtk_variant_array_clear_lookup(vtkVariantArray* sself); +extern "C" vtkVersion * vtkVersion_new () ; +extern "C" void vtkVersion_destructor (vtkVersion * sself) ; +extern "C" const char* vtk_version_get_vtk_version(vtkVersion* sself); +extern "C" const char* vtk_version_get_vtk_version_full(vtkVersion* sself); +extern "C" int vtk_version_get_vtk_major_version(vtkVersion* sself); +extern "C" int vtk_version_get_vtk_minor_version(vtkVersion* sself); +extern "C" int vtk_version_get_vtk_build_version(vtkVersion* sself); +extern "C" const char* vtk_version_get_vtk_source_version(vtkVersion* sself); +extern "C" vtkVoidArray * vtkVoidArray_new () ; +extern "C" void vtkVoidArray_destructor (vtkVoidArray * sself) ; +extern "C" int vtk_void_array_allocate(vtkVoidArray* sself, long long sz, long long ext); +extern "C" void vtk_void_array_initialize(vtkVoidArray* sself); +extern "C" int vtk_void_array_get_data_type(vtkVoidArray* sself); +extern "C" int vtk_void_array_get_data_type_size(vtkVoidArray* sself); +extern "C" void vtk_void_array_set_number_of_pointers(vtkVoidArray* sself, long long number); +extern "C" long long vtk_void_array_get_number_of_pointers(vtkVoidArray* sself); +extern "C" void* vtk_void_array_get_void_pointer(vtkVoidArray* sself, long long id); +extern "C" void vtk_void_array_set_void_pointer(vtkVoidArray* sself, long long id, void* ptr); +extern "C" void vtk_void_array_insert_void_pointer(vtkVoidArray* sself, long long i, void* ptr); +extern "C" long long vtk_void_array_insert_next_void_pointer(vtkVoidArray* sself, void* tuple); +extern "C" void vtk_void_array_reset(vtkVoidArray* sself); +extern "C" void vtk_void_array_squeeze(vtkVoidArray* sself); +extern "C" vtkWeakReference * vtkWeakReference_new () ; +extern "C" void vtkWeakReference_destructor (vtkWeakReference * sself) ; +extern "C" vtkXMLFileOutputWindow * vtkXMLFileOutputWindow_new () ; +extern "C" void vtkXMLFileOutputWindow_destructor (vtkXMLFileOutputWindow * sself) ; +extern "C" void vtk_xml_file_output_window_display_text(vtkXMLFileOutputWindow* sself, const char* p0); +extern "C" void vtk_xml_file_output_window_display_tag(vtkXMLFileOutputWindow* sself, const char* p0); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h index 3e7878d..8580d50 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_data_model.h @@ -44,7 +44,6 @@ #include #include #include -#include #include #include #include @@ -60,7 +59,6 @@ #include #include #include -#include #include #include #include @@ -230,7 +228,6 @@ #include #include #include -#include #include #include #include @@ -282,573 +279,1702 @@ #include // Declare exported functions -extern "C" vtkNew < vtkAMRDataInternals > vtkAMRDataInternals_new () ; -extern "C" void vtkAMRDataInternals_destructor (vtkNew < vtkAMRDataInternals > sself) ; -extern "C" void * vtkAMRDataInternals_get_ptr (vtkNew < vtkAMRDataInternals > sself) ; -extern "C" vtkNew < vtkAdjacentVertexIterator > vtkAdjacentVertexIterator_new () ; -extern "C" void vtkAdjacentVertexIterator_destructor (vtkNew < vtkAdjacentVertexIterator > sself) ; -extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkNew < vtkAdjacentVertexIterator > sself) ; -extern "C" vtkNew < vtkAnimationScene > vtkAnimationScene_new () ; -extern "C" void vtkAnimationScene_destructor (vtkNew < vtkAnimationScene > sself) ; -extern "C" void * vtkAnimationScene_get_ptr (vtkNew < vtkAnimationScene > sself) ; -extern "C" vtkNew < vtkAnnotation > vtkAnnotation_new () ; -extern "C" void vtkAnnotation_destructor (vtkNew < vtkAnnotation > sself) ; -extern "C" void * vtkAnnotation_get_ptr (vtkNew < vtkAnnotation > sself) ; -extern "C" vtkNew < vtkAnnotationLayers > vtkAnnotationLayers_new () ; -extern "C" void vtkAnnotationLayers_destructor (vtkNew < vtkAnnotationLayers > sself) ; -extern "C" void * vtkAnnotationLayers_get_ptr (vtkNew < vtkAnnotationLayers > sself) ; -extern "C" vtkNew < vtkArrayData > vtkArrayData_new () ; -extern "C" void vtkArrayData_destructor (vtkNew < vtkArrayData > sself) ; -extern "C" void * vtkArrayData_get_ptr (vtkNew < vtkArrayData > sself) ; -extern "C" vtkNew < vtkAttributesErrorMetric > vtkAttributesErrorMetric_new () ; -extern "C" void vtkAttributesErrorMetric_destructor (vtkNew < vtkAttributesErrorMetric > sself) ; -extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkNew < vtkAttributesErrorMetric > sself) ; -extern "C" vtkNew < vtkBSPCuts > vtkBSPCuts_new () ; -extern "C" void vtkBSPCuts_destructor (vtkNew < vtkBSPCuts > sself) ; -extern "C" void * vtkBSPCuts_get_ptr (vtkNew < vtkBSPCuts > sself) ; -extern "C" vtkNew < vtkBSPIntersections > vtkBSPIntersections_new () ; -extern "C" void vtkBSPIntersections_destructor (vtkNew < vtkBSPIntersections > sself) ; -extern "C" void * vtkBSPIntersections_get_ptr (vtkNew < vtkBSPIntersections > sself) ; -extern "C" vtkNew < vtkBezierCurve > vtkBezierCurve_new () ; -extern "C" void vtkBezierCurve_destructor (vtkNew < vtkBezierCurve > sself) ; -extern "C" void * vtkBezierCurve_get_ptr (vtkNew < vtkBezierCurve > sself) ; -extern "C" vtkNew < vtkBezierHexahedron > vtkBezierHexahedron_new () ; -extern "C" void vtkBezierHexahedron_destructor (vtkNew < vtkBezierHexahedron > sself) ; -extern "C" void * vtkBezierHexahedron_get_ptr (vtkNew < vtkBezierHexahedron > sself) ; -extern "C" vtkNew < vtkBezierInterpolation > vtkBezierInterpolation_new () ; -extern "C" void vtkBezierInterpolation_destructor (vtkNew < vtkBezierInterpolation > sself) ; -extern "C" void * vtkBezierInterpolation_get_ptr (vtkNew < vtkBezierInterpolation > sself) ; -extern "C" vtkNew < vtkBezierQuadrilateral > vtkBezierQuadrilateral_new () ; -extern "C" void vtkBezierQuadrilateral_destructor (vtkNew < vtkBezierQuadrilateral > sself) ; -extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkNew < vtkBezierQuadrilateral > sself) ; -extern "C" vtkNew < vtkBezierTetra > vtkBezierTetra_new () ; -extern "C" void vtkBezierTetra_destructor (vtkNew < vtkBezierTetra > sself) ; -extern "C" void * vtkBezierTetra_get_ptr (vtkNew < vtkBezierTetra > sself) ; -extern "C" vtkNew < vtkBezierTriangle > vtkBezierTriangle_new () ; -extern "C" void vtkBezierTriangle_destructor (vtkNew < vtkBezierTriangle > sself) ; -extern "C" void * vtkBezierTriangle_get_ptr (vtkNew < vtkBezierTriangle > sself) ; -extern "C" vtkNew < vtkBezierWedge > vtkBezierWedge_new () ; -extern "C" void vtkBezierWedge_destructor (vtkNew < vtkBezierWedge > sself) ; -extern "C" void * vtkBezierWedge_get_ptr (vtkNew < vtkBezierWedge > sself) ; -extern "C" vtkNew < vtkBiQuadraticQuad > vtkBiQuadraticQuad_new () ; -extern "C" void vtkBiQuadraticQuad_destructor (vtkNew < vtkBiQuadraticQuad > sself) ; -extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkNew < vtkBiQuadraticQuad > sself) ; -extern "C" vtkNew < vtkBiQuadraticQuadraticHexahedron > vtkBiQuadraticQuadraticHexahedron_new () ; -extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) ; -extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) ; -extern "C" vtkNew < vtkBiQuadraticQuadraticWedge > vtkBiQuadraticQuadraticWedge_new () ; -extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkNew < vtkBiQuadraticQuadraticWedge > sself) ; -extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkNew < vtkBiQuadraticQuadraticWedge > sself) ; -extern "C" vtkNew < vtkBiQuadraticTriangle > vtkBiQuadraticTriangle_new () ; -extern "C" void vtkBiQuadraticTriangle_destructor (vtkNew < vtkBiQuadraticTriangle > sself) ; -extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkNew < vtkBiQuadraticTriangle > sself) ; -extern "C" vtkNew < vtkBox > vtkBox_new () ; -extern "C" void vtkBox_destructor (vtkNew < vtkBox > sself) ; -extern "C" void * vtkBox_get_ptr (vtkNew < vtkBox > sself) ; -extern "C" vtkNew < vtkCellArray > vtkCellArray_new () ; -extern "C" void vtkCellArray_destructor (vtkNew < vtkCellArray > sself) ; -extern "C" void * vtkCellArray_get_ptr (vtkNew < vtkCellArray > sself) ; -extern "C" vtkNew < vtkCellArrayIterator > vtkCellArrayIterator_new () ; -extern "C" void vtkCellArrayIterator_destructor (vtkNew < vtkCellArrayIterator > sself) ; -extern "C" void * vtkCellArrayIterator_get_ptr (vtkNew < vtkCellArrayIterator > sself) ; -extern "C" vtkNew < vtkCellData > vtkCellData_new () ; -extern "C" void vtkCellData_destructor (vtkNew < vtkCellData > sself) ; -extern "C" void * vtkCellData_get_ptr (vtkNew < vtkCellData > sself) ; -extern "C" vtkNew < vtkCellLinks > vtkCellLinks_new () ; -extern "C" void vtkCellLinks_destructor (vtkNew < vtkCellLinks > sself) ; -extern "C" void * vtkCellLinks_get_ptr (vtkNew < vtkCellLinks > sself) ; -extern "C" vtkNew < vtkCellLocator > vtkCellLocator_new () ; -extern "C" void vtkCellLocator_destructor (vtkNew < vtkCellLocator > sself) ; -extern "C" void * vtkCellLocator_get_ptr (vtkNew < vtkCellLocator > sself) ; -extern "C" vtkNew < vtkCellLocatorStrategy > vtkCellLocatorStrategy_new () ; -extern "C" void vtkCellLocatorStrategy_destructor (vtkNew < vtkCellLocatorStrategy > sself) ; -extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkNew < vtkCellLocatorStrategy > sself) ; -extern "C" vtkNew < vtkCellTreeLocator > vtkCellTreeLocator_new () ; -extern "C" void vtkCellTreeLocator_destructor (vtkNew < vtkCellTreeLocator > sself) ; -extern "C" void * vtkCellTreeLocator_get_ptr (vtkNew < vtkCellTreeLocator > sself) ; -extern "C" vtkNew < vtkCellTypes > vtkCellTypes_new () ; -extern "C" void vtkCellTypes_destructor (vtkNew < vtkCellTypes > sself) ; -extern "C" void * vtkCellTypes_get_ptr (vtkNew < vtkCellTypes > sself) ; -extern "C" vtkNew < vtkClosestNPointsStrategy > vtkClosestNPointsStrategy_new () ; -extern "C" void vtkClosestNPointsStrategy_destructor (vtkNew < vtkClosestNPointsStrategy > sself) ; -extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkNew < vtkClosestNPointsStrategy > sself) ; -extern "C" vtkNew < vtkClosestPointStrategy > vtkClosestPointStrategy_new () ; -extern "C" void vtkClosestPointStrategy_destructor (vtkNew < vtkClosestPointStrategy > sself) ; -extern "C" void * vtkClosestPointStrategy_get_ptr (vtkNew < vtkClosestPointStrategy > sself) ; -extern "C" vtkNew < vtkCone > vtkCone_new () ; -extern "C" void vtkCone_destructor (vtkNew < vtkCone > sself) ; -extern "C" void * vtkCone_get_ptr (vtkNew < vtkCone > sself) ; -extern "C" vtkNew < vtkConvexPointSet > vtkConvexPointSet_new () ; -extern "C" void vtkConvexPointSet_destructor (vtkNew < vtkConvexPointSet > sself) ; -extern "C" void * vtkConvexPointSet_get_ptr (vtkNew < vtkConvexPointSet > sself) ; -extern "C" vtkNew < vtkCoordinateFrame > vtkCoordinateFrame_new () ; -extern "C" void vtkCoordinateFrame_destructor (vtkNew < vtkCoordinateFrame > sself) ; -extern "C" void * vtkCoordinateFrame_get_ptr (vtkNew < vtkCoordinateFrame > sself) ; -extern "C" vtkNew < vtkCubicLine > vtkCubicLine_new () ; -extern "C" void vtkCubicLine_destructor (vtkNew < vtkCubicLine > sself) ; -extern "C" void * vtkCubicLine_get_ptr (vtkNew < vtkCubicLine > sself) ; -extern "C" vtkNew < vtkCylinder > vtkCylinder_new () ; -extern "C" void vtkCylinder_destructor (vtkNew < vtkCylinder > sself) ; -extern "C" void * vtkCylinder_get_ptr (vtkNew < vtkCylinder > sself) ; -extern "C" vtkNew < vtkDataAssembly > vtkDataAssembly_new () ; -extern "C" void vtkDataAssembly_destructor (vtkNew < vtkDataAssembly > sself) ; -extern "C" void * vtkDataAssembly_get_ptr (vtkNew < vtkDataAssembly > sself) ; -extern "C" vtkNew < vtkDataAssemblyUtilities > vtkDataAssemblyUtilities_new () ; -extern "C" void vtkDataAssemblyUtilities_destructor (vtkNew < vtkDataAssemblyUtilities > sself) ; -extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkNew < vtkDataAssemblyUtilities > sself) ; -extern "C" vtkNew < vtkDataObject > vtkDataObject_new () ; -extern "C" void vtkDataObject_destructor (vtkNew < vtkDataObject > sself) ; -extern "C" void * vtkDataObject_get_ptr (vtkNew < vtkDataObject > sself) ; -extern "C" vtkNew < vtkDataObjectCollection > vtkDataObjectCollection_new () ; -extern "C" void vtkDataObjectCollection_destructor (vtkNew < vtkDataObjectCollection > sself) ; -extern "C" void * vtkDataObjectCollection_get_ptr (vtkNew < vtkDataObjectCollection > sself) ; -extern "C" vtkNew < vtkDataObjectTreeIterator > vtkDataObjectTreeIterator_new () ; -extern "C" void vtkDataObjectTreeIterator_destructor (vtkNew < vtkDataObjectTreeIterator > sself) ; -extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkNew < vtkDataObjectTreeIterator > sself) ; -extern "C" vtkNew < vtkDataObjectTypes > vtkDataObjectTypes_new () ; -extern "C" void vtkDataObjectTypes_destructor (vtkNew < vtkDataObjectTypes > sself) ; -extern "C" void * vtkDataObjectTypes_get_ptr (vtkNew < vtkDataObjectTypes > sself) ; -extern "C" vtkNew < vtkDataSetAttributes > vtkDataSetAttributes_new () ; -extern "C" void vtkDataSetAttributes_destructor (vtkNew < vtkDataSetAttributes > sself) ; -extern "C" void * vtkDataSetAttributes_get_ptr (vtkNew < vtkDataSetAttributes > sself) ; -extern "C" vtkNew < vtkDataSetCellIterator > vtkDataSetCellIterator_new () ; -extern "C" void vtkDataSetCellIterator_destructor (vtkNew < vtkDataSetCellIterator > sself) ; -extern "C" void * vtkDataSetCellIterator_get_ptr (vtkNew < vtkDataSetCellIterator > sself) ; -extern "C" vtkNew < vtkDataSetCollection > vtkDataSetCollection_new () ; -extern "C" void vtkDataSetCollection_destructor (vtkNew < vtkDataSetCollection > sself) ; -extern "C" void * vtkDataSetCollection_get_ptr (vtkNew < vtkDataSetCollection > sself) ; -extern "C" vtkNew < vtkDirectedAcyclicGraph > vtkDirectedAcyclicGraph_new () ; -extern "C" void vtkDirectedAcyclicGraph_destructor (vtkNew < vtkDirectedAcyclicGraph > sself) ; -extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkNew < vtkDirectedAcyclicGraph > sself) ; -extern "C" vtkNew < vtkDirectedGraph > vtkDirectedGraph_new () ; -extern "C" void vtkDirectedGraph_destructor (vtkNew < vtkDirectedGraph > sself) ; -extern "C" void * vtkDirectedGraph_get_ptr (vtkNew < vtkDirectedGraph > sself) ; -extern "C" vtkNew < vtkEdgeListIterator > vtkEdgeListIterator_new () ; -extern "C" void vtkEdgeListIterator_destructor (vtkNew < vtkEdgeListIterator > sself) ; -extern "C" void * vtkEdgeListIterator_get_ptr (vtkNew < vtkEdgeListIterator > sself) ; -extern "C" vtkNew < vtkEdgeTable > vtkEdgeTable_new () ; -extern "C" void vtkEdgeTable_destructor (vtkNew < vtkEdgeTable > sself) ; -extern "C" void * vtkEdgeTable_get_ptr (vtkNew < vtkEdgeTable > sself) ; -extern "C" vtkNew < vtkEmptyCell > vtkEmptyCell_new () ; -extern "C" void vtkEmptyCell_destructor (vtkNew < vtkEmptyCell > sself) ; -extern "C" void * vtkEmptyCell_get_ptr (vtkNew < vtkEmptyCell > sself) ; -extern "C" vtkNew < vtkExplicitStructuredGrid > vtkExplicitStructuredGrid_new () ; -extern "C" void vtkExplicitStructuredGrid_destructor (vtkNew < vtkExplicitStructuredGrid > sself) ; -extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkNew < vtkExplicitStructuredGrid > sself) ; -extern "C" vtkNew < vtkExtractStructuredGridHelper > vtkExtractStructuredGridHelper_new () ; -extern "C" void vtkExtractStructuredGridHelper_destructor (vtkNew < vtkExtractStructuredGridHelper > sself) ; -extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkNew < vtkExtractStructuredGridHelper > sself) ; -extern "C" vtkNew < vtkFieldData > vtkFieldData_new () ; -extern "C" void vtkFieldData_destructor (vtkNew < vtkFieldData > sself) ; -extern "C" void * vtkFieldData_get_ptr (vtkNew < vtkFieldData > sself) ; -extern "C" vtkNew < vtkGenericAttributeCollection > vtkGenericAttributeCollection_new () ; -extern "C" void vtkGenericAttributeCollection_destructor (vtkNew < vtkGenericAttributeCollection > sself) ; -extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkNew < vtkGenericAttributeCollection > sself) ; -extern "C" vtkNew < vtkGenericCell > vtkGenericCell_new () ; -extern "C" void vtkGenericCell_destructor (vtkNew < vtkGenericCell > sself) ; -extern "C" void * vtkGenericCell_get_ptr (vtkNew < vtkGenericCell > sself) ; -extern "C" vtkNew < vtkGenericEdgeTable > vtkGenericEdgeTable_new () ; -extern "C" void vtkGenericEdgeTable_destructor (vtkNew < vtkGenericEdgeTable > sself) ; -extern "C" void * vtkGenericEdgeTable_get_ptr (vtkNew < vtkGenericEdgeTable > sself) ; -extern "C" vtkNew < vtkGenericInterpolatedVelocityField > vtkGenericInterpolatedVelocityField_new () ; -extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkNew < vtkGenericInterpolatedVelocityField > sself) ; -extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkNew < vtkGenericInterpolatedVelocityField > sself) ; -extern "C" vtkNew < vtkGeometricErrorMetric > vtkGeometricErrorMetric_new () ; -extern "C" void vtkGeometricErrorMetric_destructor (vtkNew < vtkGeometricErrorMetric > sself) ; -extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkNew < vtkGeometricErrorMetric > sself) ; -extern "C" vtkNew < vtkGraphEdge > vtkGraphEdge_new () ; -extern "C" void vtkGraphEdge_destructor (vtkNew < vtkGraphEdge > sself) ; -extern "C" void * vtkGraphEdge_get_ptr (vtkNew < vtkGraphEdge > sself) ; -extern "C" vtkNew < vtkGraphInternals > vtkGraphInternals_new () ; -extern "C" void vtkGraphInternals_destructor (vtkNew < vtkGraphInternals > sself) ; -extern "C" void * vtkGraphInternals_get_ptr (vtkNew < vtkGraphInternals > sself) ; -extern "C" vtkNew < vtkHexagonalPrism > vtkHexagonalPrism_new () ; -extern "C" void vtkHexagonalPrism_destructor (vtkNew < vtkHexagonalPrism > sself) ; -extern "C" void * vtkHexagonalPrism_get_ptr (vtkNew < vtkHexagonalPrism > sself) ; -extern "C" vtkNew < vtkHexahedron > vtkHexahedron_new () ; -extern "C" void vtkHexahedron_destructor (vtkNew < vtkHexahedron > sself) ; -extern "C" void * vtkHexahedron_get_ptr (vtkNew < vtkHexahedron > sself) ; -extern "C" vtkNew < vtkHierarchicalBoxDataIterator > vtkHierarchicalBoxDataIterator_new () ; -extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkNew < vtkHierarchicalBoxDataIterator > sself) ; -extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkNew < vtkHierarchicalBoxDataIterator > sself) ; -extern "C" vtkNew < vtkHierarchicalBoxDataSet > vtkHierarchicalBoxDataSet_new () ; -extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkNew < vtkHierarchicalBoxDataSet > sself) ; -extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkNew < vtkHierarchicalBoxDataSet > sself) ; -extern "C" vtkNew < vtkHyperTreeGrid > vtkHyperTreeGrid_new () ; -extern "C" void vtkHyperTreeGrid_destructor (vtkNew < vtkHyperTreeGrid > sself) ; -extern "C" void * vtkHyperTreeGrid_get_ptr (vtkNew < vtkHyperTreeGrid > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedCursor > vtkHyperTreeGridNonOrientedCursor_new () ; -extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > vtkHyperTreeGridNonOrientedGeometryCursor_new () ; -extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > vtkHyperTreeGridNonOrientedMooreSuperCursor_new () ; -extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () ; -extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () ; -extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > sself) ; -extern "C" vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () ; -extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > sself) ; -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > sself) ; -extern "C" vtkNew < vtkHyperTreeGridOrientedCursor > vtkHyperTreeGridOrientedCursor_new () ; -extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkNew < vtkHyperTreeGridOrientedCursor > sself) ; -extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedCursor > sself) ; -extern "C" vtkNew < vtkHyperTreeGridOrientedGeometryCursor > vtkHyperTreeGridOrientedGeometryCursor_new () ; -extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) ; -extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) ; -extern "C" vtkNew < vtkImageData > vtkImageData_new () ; -extern "C" void vtkImageData_destructor (vtkNew < vtkImageData > sself) ; -extern "C" void * vtkImageData_get_ptr (vtkNew < vtkImageData > sself) ; -extern "C" vtkNew < vtkImageTransform > vtkImageTransform_new () ; -extern "C" void vtkImageTransform_destructor (vtkNew < vtkImageTransform > sself) ; -extern "C" void * vtkImageTransform_get_ptr (vtkNew < vtkImageTransform > sself) ; -extern "C" vtkNew < vtkImplicitBoolean > vtkImplicitBoolean_new () ; -extern "C" void vtkImplicitBoolean_destructor (vtkNew < vtkImplicitBoolean > sself) ; -extern "C" void * vtkImplicitBoolean_get_ptr (vtkNew < vtkImplicitBoolean > sself) ; -extern "C" vtkNew < vtkImplicitDataSet > vtkImplicitDataSet_new () ; -extern "C" void vtkImplicitDataSet_destructor (vtkNew < vtkImplicitDataSet > sself) ; -extern "C" void * vtkImplicitDataSet_get_ptr (vtkNew < vtkImplicitDataSet > sself) ; -extern "C" vtkNew < vtkImplicitFunctionCollection > vtkImplicitFunctionCollection_new () ; -extern "C" void vtkImplicitFunctionCollection_destructor (vtkNew < vtkImplicitFunctionCollection > sself) ; -extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkNew < vtkImplicitFunctionCollection > sself) ; -extern "C" vtkNew < vtkImplicitHalo > vtkImplicitHalo_new () ; -extern "C" void vtkImplicitHalo_destructor (vtkNew < vtkImplicitHalo > sself) ; -extern "C" void * vtkImplicitHalo_get_ptr (vtkNew < vtkImplicitHalo > sself) ; -extern "C" vtkNew < vtkImplicitSelectionLoop > vtkImplicitSelectionLoop_new () ; -extern "C" void vtkImplicitSelectionLoop_destructor (vtkNew < vtkImplicitSelectionLoop > sself) ; -extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkNew < vtkImplicitSelectionLoop > sself) ; -extern "C" vtkNew < vtkImplicitSum > vtkImplicitSum_new () ; -extern "C" void vtkImplicitSum_destructor (vtkNew < vtkImplicitSum > sself) ; -extern "C" void * vtkImplicitSum_get_ptr (vtkNew < vtkImplicitSum > sself) ; -extern "C" vtkNew < vtkImplicitVolume > vtkImplicitVolume_new () ; -extern "C" void vtkImplicitVolume_destructor (vtkNew < vtkImplicitVolume > sself) ; -extern "C" void * vtkImplicitVolume_get_ptr (vtkNew < vtkImplicitVolume > sself) ; -extern "C" vtkNew < vtkImplicitWindowFunction > vtkImplicitWindowFunction_new () ; -extern "C" void vtkImplicitWindowFunction_destructor (vtkNew < vtkImplicitWindowFunction > sself) ; -extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkNew < vtkImplicitWindowFunction > sself) ; -extern "C" vtkNew < vtkInEdgeIterator > vtkInEdgeIterator_new () ; -extern "C" void vtkInEdgeIterator_destructor (vtkNew < vtkInEdgeIterator > sself) ; -extern "C" void * vtkInEdgeIterator_get_ptr (vtkNew < vtkInEdgeIterator > sself) ; -extern "C" vtkNew < vtkIncrementalOctreeNode > vtkIncrementalOctreeNode_new () ; -extern "C" void vtkIncrementalOctreeNode_destructor (vtkNew < vtkIncrementalOctreeNode > sself) ; -extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkNew < vtkIncrementalOctreeNode > sself) ; -extern "C" vtkNew < vtkIncrementalOctreePointLocator > vtkIncrementalOctreePointLocator_new () ; -extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkNew < vtkIncrementalOctreePointLocator > sself) ; -extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkNew < vtkIncrementalOctreePointLocator > sself) ; -extern "C" vtkNew < vtkIterativeClosestPointTransform > vtkIterativeClosestPointTransform_new () ; -extern "C" void vtkIterativeClosestPointTransform_destructor (vtkNew < vtkIterativeClosestPointTransform > sself) ; -extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkNew < vtkIterativeClosestPointTransform > sself) ; -extern "C" vtkNew < vtkKdNode > vtkKdNode_new () ; -extern "C" void vtkKdNode_destructor (vtkNew < vtkKdNode > sself) ; -extern "C" void * vtkKdNode_get_ptr (vtkNew < vtkKdNode > sself) ; -extern "C" vtkNew < vtkKdTree > vtkKdTree_new () ; -extern "C" void vtkKdTree_destructor (vtkNew < vtkKdTree > sself) ; -extern "C" void * vtkKdTree_get_ptr (vtkNew < vtkKdTree > sself) ; -extern "C" vtkNew < vtkKdTreePointLocator > vtkKdTreePointLocator_new () ; -extern "C" void vtkKdTreePointLocator_destructor (vtkNew < vtkKdTreePointLocator > sself) ; -extern "C" void * vtkKdTreePointLocator_get_ptr (vtkNew < vtkKdTreePointLocator > sself) ; -extern "C" vtkNew < vtkLagrangeCurve > vtkLagrangeCurve_new () ; -extern "C" void vtkLagrangeCurve_destructor (vtkNew < vtkLagrangeCurve > sself) ; -extern "C" void * vtkLagrangeCurve_get_ptr (vtkNew < vtkLagrangeCurve > sself) ; -extern "C" vtkNew < vtkLagrangeHexahedron > vtkLagrangeHexahedron_new () ; -extern "C" void vtkLagrangeHexahedron_destructor (vtkNew < vtkLagrangeHexahedron > sself) ; -extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkNew < vtkLagrangeHexahedron > sself) ; -extern "C" vtkNew < vtkLagrangeInterpolation > vtkLagrangeInterpolation_new () ; -extern "C" void vtkLagrangeInterpolation_destructor (vtkNew < vtkLagrangeInterpolation > sself) ; -extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkNew < vtkLagrangeInterpolation > sself) ; -extern "C" vtkNew < vtkLagrangeQuadrilateral > vtkLagrangeQuadrilateral_new () ; -extern "C" void vtkLagrangeQuadrilateral_destructor (vtkNew < vtkLagrangeQuadrilateral > sself) ; -extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkNew < vtkLagrangeQuadrilateral > sself) ; -extern "C" vtkNew < vtkLagrangeTetra > vtkLagrangeTetra_new () ; -extern "C" void vtkLagrangeTetra_destructor (vtkNew < vtkLagrangeTetra > sself) ; -extern "C" void * vtkLagrangeTetra_get_ptr (vtkNew < vtkLagrangeTetra > sself) ; -extern "C" vtkNew < vtkLagrangeTriangle > vtkLagrangeTriangle_new () ; -extern "C" void vtkLagrangeTriangle_destructor (vtkNew < vtkLagrangeTriangle > sself) ; -extern "C" void * vtkLagrangeTriangle_get_ptr (vtkNew < vtkLagrangeTriangle > sself) ; -extern "C" vtkNew < vtkLagrangeWedge > vtkLagrangeWedge_new () ; -extern "C" void vtkLagrangeWedge_destructor (vtkNew < vtkLagrangeWedge > sself) ; -extern "C" void * vtkLagrangeWedge_get_ptr (vtkNew < vtkLagrangeWedge > sself) ; -extern "C" vtkNew < vtkLine > vtkLine_new () ; -extern "C" void vtkLine_destructor (vtkNew < vtkLine > sself) ; -extern "C" void * vtkLine_get_ptr (vtkNew < vtkLine > sself) ; -extern "C" vtkNew < vtkMeanValueCoordinatesInterpolator > vtkMeanValueCoordinatesInterpolator_new () ; -extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) ; -extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) ; -extern "C" vtkNew < vtkMergePoints > vtkMergePoints_new () ; -extern "C" void vtkMergePoints_destructor (vtkNew < vtkMergePoints > sself) ; -extern "C" void * vtkMergePoints_get_ptr (vtkNew < vtkMergePoints > sself) ; -extern "C" vtkNew < vtkMolecule > vtkMolecule_new () ; -extern "C" void vtkMolecule_destructor (vtkNew < vtkMolecule > sself) ; -extern "C" void * vtkMolecule_get_ptr (vtkNew < vtkMolecule > sself) ; -extern "C" vtkNew < vtkMultiBlockDataSet > vtkMultiBlockDataSet_new () ; -extern "C" void vtkMultiBlockDataSet_destructor (vtkNew < vtkMultiBlockDataSet > sself) ; -extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkNew < vtkMultiBlockDataSet > sself) ; -extern "C" vtkNew < vtkMultiPieceDataSet > vtkMultiPieceDataSet_new () ; -extern "C" void vtkMultiPieceDataSet_destructor (vtkNew < vtkMultiPieceDataSet > sself) ; -extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkNew < vtkMultiPieceDataSet > sself) ; -extern "C" vtkNew < vtkMutableDirectedGraph > vtkMutableDirectedGraph_new () ; -extern "C" void vtkMutableDirectedGraph_destructor (vtkNew < vtkMutableDirectedGraph > sself) ; -extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkNew < vtkMutableDirectedGraph > sself) ; -extern "C" vtkNew < vtkMutableUndirectedGraph > vtkMutableUndirectedGraph_new () ; -extern "C" void vtkMutableUndirectedGraph_destructor (vtkNew < vtkMutableUndirectedGraph > sself) ; -extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkNew < vtkMutableUndirectedGraph > sself) ; -extern "C" vtkNew < vtkNonMergingPointLocator > vtkNonMergingPointLocator_new () ; -extern "C" void vtkNonMergingPointLocator_destructor (vtkNew < vtkNonMergingPointLocator > sself) ; -extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNew < vtkNonMergingPointLocator > sself) ; -extern "C" vtkNew < vtkNonOverlappingAMR > vtkNonOverlappingAMR_new () ; -extern "C" void vtkNonOverlappingAMR_destructor (vtkNew < vtkNonOverlappingAMR > sself) ; -extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNew < vtkNonOverlappingAMR > sself) ; -extern "C" vtkNew < vtkOctreePointLocator > vtkOctreePointLocator_new () ; -extern "C" void vtkOctreePointLocator_destructor (vtkNew < vtkOctreePointLocator > sself) ; -extern "C" void * vtkOctreePointLocator_get_ptr (vtkNew < vtkOctreePointLocator > sself) ; -extern "C" vtkNew < vtkOctreePointLocatorNode > vtkOctreePointLocatorNode_new () ; -extern "C" void vtkOctreePointLocatorNode_destructor (vtkNew < vtkOctreePointLocatorNode > sself) ; -extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkNew < vtkOctreePointLocatorNode > sself) ; -extern "C" vtkNew < vtkOrderedTriangulator > vtkOrderedTriangulator_new () ; -extern "C" void vtkOrderedTriangulator_destructor (vtkNew < vtkOrderedTriangulator > sself) ; -extern "C" void * vtkOrderedTriangulator_get_ptr (vtkNew < vtkOrderedTriangulator > sself) ; -extern "C" vtkNew < vtkOutEdgeIterator > vtkOutEdgeIterator_new () ; -extern "C" void vtkOutEdgeIterator_destructor (vtkNew < vtkOutEdgeIterator > sself) ; -extern "C" void * vtkOutEdgeIterator_get_ptr (vtkNew < vtkOutEdgeIterator > sself) ; -extern "C" vtkNew < vtkOverlappingAMR > vtkOverlappingAMR_new () ; -extern "C" void vtkOverlappingAMR_destructor (vtkNew < vtkOverlappingAMR > sself) ; -extern "C" void * vtkOverlappingAMR_get_ptr (vtkNew < vtkOverlappingAMR > sself) ; -extern "C" vtkNew < vtkPartitionedDataSet > vtkPartitionedDataSet_new () ; -extern "C" void vtkPartitionedDataSet_destructor (vtkNew < vtkPartitionedDataSet > sself) ; -extern "C" void * vtkPartitionedDataSet_get_ptr (vtkNew < vtkPartitionedDataSet > sself) ; -extern "C" vtkNew < vtkPartitionedDataSetCollection > vtkPartitionedDataSetCollection_new () ; -extern "C" void vtkPartitionedDataSetCollection_destructor (vtkNew < vtkPartitionedDataSetCollection > sself) ; -extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkNew < vtkPartitionedDataSetCollection > sself) ; -extern "C" vtkNew < vtkPath > vtkPath_new () ; -extern "C" void vtkPath_destructor (vtkNew < vtkPath > sself) ; -extern "C" void * vtkPath_get_ptr (vtkNew < vtkPath > sself) ; -extern "C" vtkNew < vtkPentagonalPrism > vtkPentagonalPrism_new () ; -extern "C" void vtkPentagonalPrism_destructor (vtkNew < vtkPentagonalPrism > sself) ; -extern "C" void * vtkPentagonalPrism_get_ptr (vtkNew < vtkPentagonalPrism > sself) ; -extern "C" vtkNew < vtkPerlinNoise > vtkPerlinNoise_new () ; -extern "C" void vtkPerlinNoise_destructor (vtkNew < vtkPerlinNoise > sself) ; -extern "C" void * vtkPerlinNoise_get_ptr (vtkNew < vtkPerlinNoise > sself) ; -extern "C" vtkNew < vtkPiecewiseFunction > vtkPiecewiseFunction_new () ; -extern "C" void vtkPiecewiseFunction_destructor (vtkNew < vtkPiecewiseFunction > sself) ; -extern "C" void * vtkPiecewiseFunction_get_ptr (vtkNew < vtkPiecewiseFunction > sself) ; -extern "C" vtkNew < vtkPixel > vtkPixel_new () ; -extern "C" void vtkPixel_destructor (vtkNew < vtkPixel > sself) ; -extern "C" void * vtkPixel_get_ptr (vtkNew < vtkPixel > sself) ; -extern "C" vtkNew < vtkPlane > vtkPlane_new () ; -extern "C" void vtkPlane_destructor (vtkNew < vtkPlane > sself) ; -extern "C" void * vtkPlane_get_ptr (vtkNew < vtkPlane > sself) ; -extern "C" vtkNew < vtkPlaneCollection > vtkPlaneCollection_new () ; -extern "C" void vtkPlaneCollection_destructor (vtkNew < vtkPlaneCollection > sself) ; -extern "C" void * vtkPlaneCollection_get_ptr (vtkNew < vtkPlaneCollection > sself) ; -extern "C" vtkNew < vtkPlanes > vtkPlanes_new () ; -extern "C" void vtkPlanes_destructor (vtkNew < vtkPlanes > sself) ; -extern "C" void * vtkPlanes_get_ptr (vtkNew < vtkPlanes > sself) ; -extern "C" vtkNew < vtkPlanesIntersection > vtkPlanesIntersection_new () ; -extern "C" void vtkPlanesIntersection_destructor (vtkNew < vtkPlanesIntersection > sself) ; -extern "C" void * vtkPlanesIntersection_get_ptr (vtkNew < vtkPlanesIntersection > sself) ; -extern "C" vtkNew < vtkPointData > vtkPointData_new () ; -extern "C" void vtkPointData_destructor (vtkNew < vtkPointData > sself) ; -extern "C" void * vtkPointData_get_ptr (vtkNew < vtkPointData > sself) ; -extern "C" vtkNew < vtkPointLocator > vtkPointLocator_new () ; -extern "C" void vtkPointLocator_destructor (vtkNew < vtkPointLocator > sself) ; -extern "C" void * vtkPointLocator_get_ptr (vtkNew < vtkPointLocator > sself) ; -extern "C" vtkNew < vtkPointSet > vtkPointSet_new () ; -extern "C" void vtkPointSet_destructor (vtkNew < vtkPointSet > sself) ; -extern "C" void * vtkPointSet_get_ptr (vtkNew < vtkPointSet > sself) ; -extern "C" vtkNew < vtkPointSetCellIterator > vtkPointSetCellIterator_new () ; -extern "C" void vtkPointSetCellIterator_destructor (vtkNew < vtkPointSetCellIterator > sself) ; -extern "C" void * vtkPointSetCellIterator_get_ptr (vtkNew < vtkPointSetCellIterator > sself) ; -extern "C" vtkNew < vtkPointsProjectedHull > vtkPointsProjectedHull_new () ; -extern "C" void vtkPointsProjectedHull_destructor (vtkNew < vtkPointsProjectedHull > sself) ; -extern "C" void * vtkPointsProjectedHull_get_ptr (vtkNew < vtkPointsProjectedHull > sself) ; -extern "C" vtkNew < vtkPolyData > vtkPolyData_new () ; -extern "C" void vtkPolyData_destructor (vtkNew < vtkPolyData > sself) ; -extern "C" void * vtkPolyData_get_ptr (vtkNew < vtkPolyData > sself) ; -extern "C" vtkNew < vtkPolyDataCollection > vtkPolyDataCollection_new () ; -extern "C" void vtkPolyDataCollection_destructor (vtkNew < vtkPolyDataCollection > sself) ; -extern "C" void * vtkPolyDataCollection_get_ptr (vtkNew < vtkPolyDataCollection > sself) ; -extern "C" vtkNew < vtkPolyLine > vtkPolyLine_new () ; -extern "C" void vtkPolyLine_destructor (vtkNew < vtkPolyLine > sself) ; -extern "C" void * vtkPolyLine_get_ptr (vtkNew < vtkPolyLine > sself) ; -extern "C" vtkNew < vtkPolyPlane > vtkPolyPlane_new () ; -extern "C" void vtkPolyPlane_destructor (vtkNew < vtkPolyPlane > sself) ; -extern "C" void * vtkPolyPlane_get_ptr (vtkNew < vtkPolyPlane > sself) ; -extern "C" vtkNew < vtkPolyVertex > vtkPolyVertex_new () ; -extern "C" void vtkPolyVertex_destructor (vtkNew < vtkPolyVertex > sself) ; -extern "C" void * vtkPolyVertex_get_ptr (vtkNew < vtkPolyVertex > sself) ; -extern "C" vtkNew < vtkPolygon > vtkPolygon_new () ; -extern "C" void vtkPolygon_destructor (vtkNew < vtkPolygon > sself) ; -extern "C" void * vtkPolygon_get_ptr (vtkNew < vtkPolygon > sself) ; -extern "C" vtkNew < vtkPolyhedron > vtkPolyhedron_new () ; -extern "C" void vtkPolyhedron_destructor (vtkNew < vtkPolyhedron > sself) ; -extern "C" void * vtkPolyhedron_get_ptr (vtkNew < vtkPolyhedron > sself) ; -extern "C" vtkNew < vtkPyramid > vtkPyramid_new () ; -extern "C" void vtkPyramid_destructor (vtkNew < vtkPyramid > sself) ; -extern "C" void * vtkPyramid_get_ptr (vtkNew < vtkPyramid > sself) ; -extern "C" vtkNew < vtkQuad > vtkQuad_new () ; -extern "C" void vtkQuad_destructor (vtkNew < vtkQuad > sself) ; -extern "C" void * vtkQuad_get_ptr (vtkNew < vtkQuad > sself) ; -extern "C" vtkNew < vtkQuadraticEdge > vtkQuadraticEdge_new () ; -extern "C" void vtkQuadraticEdge_destructor (vtkNew < vtkQuadraticEdge > sself) ; -extern "C" void * vtkQuadraticEdge_get_ptr (vtkNew < vtkQuadraticEdge > sself) ; -extern "C" vtkNew < vtkQuadraticHexahedron > vtkQuadraticHexahedron_new () ; -extern "C" void vtkQuadraticHexahedron_destructor (vtkNew < vtkQuadraticHexahedron > sself) ; -extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkNew < vtkQuadraticHexahedron > sself) ; -extern "C" vtkNew < vtkQuadraticLinearQuad > vtkQuadraticLinearQuad_new () ; -extern "C" void vtkQuadraticLinearQuad_destructor (vtkNew < vtkQuadraticLinearQuad > sself) ; -extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkNew < vtkQuadraticLinearQuad > sself) ; -extern "C" vtkNew < vtkQuadraticLinearWedge > vtkQuadraticLinearWedge_new () ; -extern "C" void vtkQuadraticLinearWedge_destructor (vtkNew < vtkQuadraticLinearWedge > sself) ; -extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkNew < vtkQuadraticLinearWedge > sself) ; -extern "C" vtkNew < vtkQuadraticPolygon > vtkQuadraticPolygon_new () ; -extern "C" void vtkQuadraticPolygon_destructor (vtkNew < vtkQuadraticPolygon > sself) ; -extern "C" void * vtkQuadraticPolygon_get_ptr (vtkNew < vtkQuadraticPolygon > sself) ; -extern "C" vtkNew < vtkQuadraticPyramid > vtkQuadraticPyramid_new () ; -extern "C" void vtkQuadraticPyramid_destructor (vtkNew < vtkQuadraticPyramid > sself) ; -extern "C" void * vtkQuadraticPyramid_get_ptr (vtkNew < vtkQuadraticPyramid > sself) ; -extern "C" vtkNew < vtkQuadraticQuad > vtkQuadraticQuad_new () ; -extern "C" void vtkQuadraticQuad_destructor (vtkNew < vtkQuadraticQuad > sself) ; -extern "C" void * vtkQuadraticQuad_get_ptr (vtkNew < vtkQuadraticQuad > sself) ; -extern "C" vtkNew < vtkQuadraticTetra > vtkQuadraticTetra_new () ; -extern "C" void vtkQuadraticTetra_destructor (vtkNew < vtkQuadraticTetra > sself) ; -extern "C" void * vtkQuadraticTetra_get_ptr (vtkNew < vtkQuadraticTetra > sself) ; -extern "C" vtkNew < vtkQuadraticTriangle > vtkQuadraticTriangle_new () ; -extern "C" void vtkQuadraticTriangle_destructor (vtkNew < vtkQuadraticTriangle > sself) ; -extern "C" void * vtkQuadraticTriangle_get_ptr (vtkNew < vtkQuadraticTriangle > sself) ; -extern "C" vtkNew < vtkQuadraticWedge > vtkQuadraticWedge_new () ; -extern "C" void vtkQuadraticWedge_destructor (vtkNew < vtkQuadraticWedge > sself) ; -extern "C" void * vtkQuadraticWedge_get_ptr (vtkNew < vtkQuadraticWedge > sself) ; -extern "C" vtkNew < vtkQuadratureSchemeDefinition > vtkQuadratureSchemeDefinition_new () ; -extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkNew < vtkQuadratureSchemeDefinition > sself) ; -extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkNew < vtkQuadratureSchemeDefinition > sself) ; -extern "C" vtkNew < vtkQuadric > vtkQuadric_new () ; -extern "C" void vtkQuadric_destructor (vtkNew < vtkQuadric > sself) ; -extern "C" void * vtkQuadric_get_ptr (vtkNew < vtkQuadric > sself) ; -extern "C" vtkNew < vtkRectilinearGrid > vtkRectilinearGrid_new () ; -extern "C" void vtkRectilinearGrid_destructor (vtkNew < vtkRectilinearGrid > sself) ; -extern "C" void * vtkRectilinearGrid_get_ptr (vtkNew < vtkRectilinearGrid > sself) ; -extern "C" vtkNew < vtkReebGraph > vtkReebGraph_new () ; -extern "C" void vtkReebGraph_destructor (vtkNew < vtkReebGraph > sself) ; -extern "C" void * vtkReebGraph_get_ptr (vtkNew < vtkReebGraph > sself) ; -extern "C" vtkNew < vtkReebGraphSimplificationMetric > vtkReebGraphSimplificationMetric_new () ; -extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkNew < vtkReebGraphSimplificationMetric > sself) ; -extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkNew < vtkReebGraphSimplificationMetric > sself) ; -extern "C" vtkNew < vtkSelection > vtkSelection_new () ; -extern "C" void vtkSelection_destructor (vtkNew < vtkSelection > sself) ; -extern "C" void * vtkSelection_get_ptr (vtkNew < vtkSelection > sself) ; -extern "C" vtkNew < vtkSelectionNode > vtkSelectionNode_new () ; -extern "C" void vtkSelectionNode_destructor (vtkNew < vtkSelectionNode > sself) ; -extern "C" void * vtkSelectionNode_get_ptr (vtkNew < vtkSelectionNode > sself) ; -extern "C" vtkNew < vtkSimpleCellTessellator > vtkSimpleCellTessellator_new () ; -extern "C" void vtkSimpleCellTessellator_destructor (vtkNew < vtkSimpleCellTessellator > sself) ; -extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkNew < vtkSimpleCellTessellator > sself) ; -extern "C" vtkNew < vtkSmoothErrorMetric > vtkSmoothErrorMetric_new () ; -extern "C" void vtkSmoothErrorMetric_destructor (vtkNew < vtkSmoothErrorMetric > sself) ; -extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkNew < vtkSmoothErrorMetric > sself) ; -extern "C" vtkNew < vtkSortFieldData > vtkSortFieldData_new () ; -extern "C" void vtkSortFieldData_destructor (vtkNew < vtkSortFieldData > sself) ; -extern "C" void * vtkSortFieldData_get_ptr (vtkNew < vtkSortFieldData > sself) ; -extern "C" vtkNew < vtkSphere > vtkSphere_new () ; -extern "C" void vtkSphere_destructor (vtkNew < vtkSphere > sself) ; -extern "C" void * vtkSphere_get_ptr (vtkNew < vtkSphere > sself) ; -extern "C" vtkNew < vtkSpheres > vtkSpheres_new () ; -extern "C" void vtkSpheres_destructor (vtkNew < vtkSpheres > sself) ; -extern "C" void * vtkSpheres_get_ptr (vtkNew < vtkSpheres > sself) ; -extern "C" vtkNew < vtkSphericalPointIterator > vtkSphericalPointIterator_new () ; -extern "C" void vtkSphericalPointIterator_destructor (vtkNew < vtkSphericalPointIterator > sself) ; -extern "C" void * vtkSphericalPointIterator_get_ptr (vtkNew < vtkSphericalPointIterator > sself) ; -extern "C" vtkNew < vtkStaticCellLinks > vtkStaticCellLinks_new () ; -extern "C" void vtkStaticCellLinks_destructor (vtkNew < vtkStaticCellLinks > sself) ; -extern "C" void * vtkStaticCellLinks_get_ptr (vtkNew < vtkStaticCellLinks > sself) ; -extern "C" vtkNew < vtkStaticCellLocator > vtkStaticCellLocator_new () ; -extern "C" void vtkStaticCellLocator_destructor (vtkNew < vtkStaticCellLocator > sself) ; -extern "C" void * vtkStaticCellLocator_get_ptr (vtkNew < vtkStaticCellLocator > sself) ; -extern "C" vtkNew < vtkStaticPointLocator > vtkStaticPointLocator_new () ; -extern "C" void vtkStaticPointLocator_destructor (vtkNew < vtkStaticPointLocator > sself) ; -extern "C" void * vtkStaticPointLocator_get_ptr (vtkNew < vtkStaticPointLocator > sself) ; -extern "C" vtkNew < vtkStaticPointLocator2D > vtkStaticPointLocator2D_new () ; -extern "C" void vtkStaticPointLocator2D_destructor (vtkNew < vtkStaticPointLocator2D > sself) ; -extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkNew < vtkStaticPointLocator2D > sself) ; -extern "C" vtkNew < vtkStructuredExtent > vtkStructuredExtent_new () ; -extern "C" void vtkStructuredExtent_destructor (vtkNew < vtkStructuredExtent > sself) ; -extern "C" void * vtkStructuredExtent_get_ptr (vtkNew < vtkStructuredExtent > sself) ; -extern "C" vtkNew < vtkStructuredGrid > vtkStructuredGrid_new () ; -extern "C" void vtkStructuredGrid_destructor (vtkNew < vtkStructuredGrid > sself) ; -extern "C" void * vtkStructuredGrid_get_ptr (vtkNew < vtkStructuredGrid > sself) ; -extern "C" vtkNew < vtkStructuredPoints > vtkStructuredPoints_new () ; -extern "C" void vtkStructuredPoints_destructor (vtkNew < vtkStructuredPoints > sself) ; -extern "C" void * vtkStructuredPoints_get_ptr (vtkNew < vtkStructuredPoints > sself) ; -extern "C" vtkNew < vtkStructuredPointsCollection > vtkStructuredPointsCollection_new () ; -extern "C" void vtkStructuredPointsCollection_destructor (vtkNew < vtkStructuredPointsCollection > sself) ; -extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkNew < vtkStructuredPointsCollection > sself) ; -extern "C" vtkNew < vtkSuperquadric > vtkSuperquadric_new () ; -extern "C" void vtkSuperquadric_destructor (vtkNew < vtkSuperquadric > sself) ; -extern "C" void * vtkSuperquadric_get_ptr (vtkNew < vtkSuperquadric > sself) ; -extern "C" vtkNew < vtkTable > vtkTable_new () ; -extern "C" void vtkTable_destructor (vtkNew < vtkTable > sself) ; -extern "C" void * vtkTable_get_ptr (vtkNew < vtkTable > sself) ; -extern "C" vtkNew < vtkTetra > vtkTetra_new () ; -extern "C" void vtkTetra_destructor (vtkNew < vtkTetra > sself) ; -extern "C" void * vtkTetra_get_ptr (vtkNew < vtkTetra > sself) ; -extern "C" vtkNew < vtkTree > vtkTree_new () ; -extern "C" void vtkTree_destructor (vtkNew < vtkTree > sself) ; -extern "C" void * vtkTree_get_ptr (vtkNew < vtkTree > sself) ; -extern "C" vtkNew < vtkTreeBFSIterator > vtkTreeBFSIterator_new () ; -extern "C" void vtkTreeBFSIterator_destructor (vtkNew < vtkTreeBFSIterator > sself) ; -extern "C" void * vtkTreeBFSIterator_get_ptr (vtkNew < vtkTreeBFSIterator > sself) ; -extern "C" vtkNew < vtkTreeDFSIterator > vtkTreeDFSIterator_new () ; -extern "C" void vtkTreeDFSIterator_destructor (vtkNew < vtkTreeDFSIterator > sself) ; -extern "C" void * vtkTreeDFSIterator_get_ptr (vtkNew < vtkTreeDFSIterator > sself) ; -extern "C" vtkNew < vtkTriQuadraticHexahedron > vtkTriQuadraticHexahedron_new () ; -extern "C" void vtkTriQuadraticHexahedron_destructor (vtkNew < vtkTriQuadraticHexahedron > sself) ; -extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkNew < vtkTriQuadraticHexahedron > sself) ; -extern "C" vtkNew < vtkTriQuadraticPyramid > vtkTriQuadraticPyramid_new () ; -extern "C" void vtkTriQuadraticPyramid_destructor (vtkNew < vtkTriQuadraticPyramid > sself) ; -extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkNew < vtkTriQuadraticPyramid > sself) ; -extern "C" vtkNew < vtkTriangle > vtkTriangle_new () ; -extern "C" void vtkTriangle_destructor (vtkNew < vtkTriangle > sself) ; -extern "C" void * vtkTriangle_get_ptr (vtkNew < vtkTriangle > sself) ; -extern "C" vtkNew < vtkTriangleStrip > vtkTriangleStrip_new () ; -extern "C" void vtkTriangleStrip_destructor (vtkNew < vtkTriangleStrip > sself) ; -extern "C" void * vtkTriangleStrip_get_ptr (vtkNew < vtkTriangleStrip > sself) ; -extern "C" vtkNew < vtkUndirectedGraph > vtkUndirectedGraph_new () ; -extern "C" void vtkUndirectedGraph_destructor (vtkNew < vtkUndirectedGraph > sself) ; -extern "C" void * vtkUndirectedGraph_get_ptr (vtkNew < vtkUndirectedGraph > sself) ; -extern "C" vtkNew < vtkUniformGrid > vtkUniformGrid_new () ; -extern "C" void vtkUniformGrid_destructor (vtkNew < vtkUniformGrid > sself) ; -extern "C" void * vtkUniformGrid_get_ptr (vtkNew < vtkUniformGrid > sself) ; -extern "C" vtkNew < vtkUniformGridAMR > vtkUniformGridAMR_new () ; -extern "C" void vtkUniformGridAMR_destructor (vtkNew < vtkUniformGridAMR > sself) ; -extern "C" void * vtkUniformGridAMR_get_ptr (vtkNew < vtkUniformGridAMR > sself) ; -extern "C" vtkNew < vtkUniformGridAMRDataIterator > vtkUniformGridAMRDataIterator_new () ; -extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkNew < vtkUniformGridAMRDataIterator > sself) ; -extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkNew < vtkUniformGridAMRDataIterator > sself) ; -extern "C" vtkNew < vtkUniformHyperTreeGrid > vtkUniformHyperTreeGrid_new () ; -extern "C" void vtkUniformHyperTreeGrid_destructor (vtkNew < vtkUniformHyperTreeGrid > sself) ; -extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkNew < vtkUniformHyperTreeGrid > sself) ; -extern "C" vtkNew < vtkUnstructuredGrid > vtkUnstructuredGrid_new () ; -extern "C" void vtkUnstructuredGrid_destructor (vtkNew < vtkUnstructuredGrid > sself) ; -extern "C" void * vtkUnstructuredGrid_get_ptr (vtkNew < vtkUnstructuredGrid > sself) ; -extern "C" vtkNew < vtkUnstructuredGridCellIterator > vtkUnstructuredGridCellIterator_new () ; -extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkNew < vtkUnstructuredGridCellIterator > sself) ; -extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkNew < vtkUnstructuredGridCellIterator > sself) ; -extern "C" vtkNew < vtkVertex > vtkVertex_new () ; -extern "C" void vtkVertex_destructor (vtkNew < vtkVertex > sself) ; -extern "C" void * vtkVertex_get_ptr (vtkNew < vtkVertex > sself) ; -extern "C" vtkNew < vtkVertexListIterator > vtkVertexListIterator_new () ; -extern "C" void vtkVertexListIterator_destructor (vtkNew < vtkVertexListIterator > sself) ; -extern "C" void * vtkVertexListIterator_get_ptr (vtkNew < vtkVertexListIterator > sself) ; -extern "C" vtkNew < vtkVoxel > vtkVoxel_new () ; -extern "C" void vtkVoxel_destructor (vtkNew < vtkVoxel > sself) ; -extern "C" void * vtkVoxel_get_ptr (vtkNew < vtkVoxel > sself) ; -extern "C" vtkNew < vtkWedge > vtkWedge_new () ; -extern "C" void vtkWedge_destructor (vtkNew < vtkWedge > sself) ; -extern "C" void * vtkWedge_get_ptr (vtkNew < vtkWedge > sself) ; -extern "C" vtkNew < vtkXMLDataElement > vtkXMLDataElement_new () ; -extern "C" void vtkXMLDataElement_destructor (vtkNew < vtkXMLDataElement > sself) ; -extern "C" void * vtkXMLDataElement_get_ptr (vtkNew < vtkXMLDataElement > sself) ; +extern "C" vtkAMRDataInternals * vtkAMRDataInternals_new () ; +extern "C" void vtkAMRDataInternals_destructor (vtkAMRDataInternals * sself) ; +extern "C" void vtk_amr_data_internals_initialize(vtkAMRDataInternals* sself); +extern "C" bool vtk_amr_data_internals_empty(vtkAMRDataInternals* sself); +extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkAMRDataInternals* sself); +extern "C" vtkAdjacentVertexIterator * vtkAdjacentVertexIterator_new () ; +extern "C" void vtkAdjacentVertexIterator_destructor (vtkAdjacentVertexIterator * sself) ; +extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkAdjacentVertexIterator* sself); +extern "C" long long vtk_adjacent_vertex_iterator_next(vtkAdjacentVertexIterator* sself); +extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkAdjacentVertexIterator* sself); +extern "C" vtkAnimationScene * vtkAnimationScene_new () ; +extern "C" void vtkAnimationScene_destructor (vtkAnimationScene * sself) ; +extern "C" void vtk_animation_scene_set_play_mode(vtkAnimationScene* sself, int _arg); +extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkAnimationScene* sself); +extern "C" int vtk_animation_scene_get_play_mode(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_set_frame_rate(vtkAnimationScene* sself, double _arg); +extern "C" double vtk_animation_scene_get_frame_rate(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_remove_all_cues(vtkAnimationScene* sself); +extern "C" int vtk_animation_scene_get_number_of_cues(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_play(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_stop(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_set_loop(vtkAnimationScene* sself, int _arg); +extern "C" int vtk_animation_scene_get_loop(vtkAnimationScene* sself); +extern "C" void vtk_animation_scene_set_animation_time(vtkAnimationScene* sself, double time); +extern "C" void vtk_animation_scene_set_time_mode(vtkAnimationScene* sself, int mode); +extern "C" int vtk_animation_scene_is_in_play(vtkAnimationScene* sself); +extern "C" vtkAnnotation * vtkAnnotation_new () ; +extern "C" void vtkAnnotation_destructor (vtkAnnotation * sself) ; +extern "C" int vtk_annotation_get_data_object_type(vtkAnnotation* sself); +extern "C" void vtk_annotation_initialize(vtkAnnotation* sself); +extern "C" unsigned long vtk_annotation_get_m_time(vtkAnnotation* sself); +extern "C" vtkAnnotationLayers * vtkAnnotationLayers_new () ; +extern "C" void vtkAnnotationLayers_destructor (vtkAnnotationLayers * sself) ; +extern "C" int vtk_annotation_layers_get_data_object_type(vtkAnnotationLayers* sself); +extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkAnnotationLayers* sself); +extern "C" void vtk_annotation_layers_initialize(vtkAnnotationLayers* sself); +extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkAnnotationLayers* sself); +extern "C" vtkArrayData * vtkArrayData_new () ; +extern "C" void vtkArrayData_destructor (vtkArrayData * sself) ; +extern "C" void vtk_array_data_clear_arrays(vtkArrayData* sself); +extern "C" long long vtk_array_data_get_number_of_arrays(vtkArrayData* sself); +extern "C" int vtk_array_data_get_data_object_type(vtkArrayData* sself); +extern "C" vtkAttributesErrorMetric * vtkAttributesErrorMetric_new () ; +extern "C" void vtkAttributesErrorMetric_destructor (vtkAttributesErrorMetric * sself) ; +extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself); +extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself, double value); +extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkAttributesErrorMetric* sself); +extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkAttributesErrorMetric* sself, double value); +extern "C" vtkBSPCuts * vtkBSPCuts_new () ; +extern "C" void vtkBSPCuts_destructor (vtkBSPCuts * sself) ; +extern "C" int vtk_bsp_cuts_get_data_object_type(vtkBSPCuts* sself); +extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkBSPCuts* sself); +extern "C" void vtk_bsp_cuts_print_tree(vtkBSPCuts* sself); +extern "C" void vtk_bsp_cuts_print_arrays(vtkBSPCuts* sself); +extern "C" vtkBSPIntersections * vtkBSPIntersections_new () ; +extern "C" void vtkBSPIntersections_destructor (vtkBSPIntersections * sself) ; +extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkBSPIntersections* sself); +extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkBSPIntersections* sself, int regionId, double x, double y, double z, double rSquared); +extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkBSPIntersections* sself); +extern "C" void vtk_bsp_intersections_set_compute_intersections_using_data_bounds(vtkBSPIntersections* sself, int c); +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on(vtkBSPIntersections* sself); +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkBSPIntersections* sself); +extern "C" vtkBezierCurve * vtkBezierCurve_new () ; +extern "C" void vtkBezierCurve_destructor (vtkBezierCurve * sself) ; +extern "C" int vtk_bezier_curve_get_cell_type(vtkBezierCurve* sself); +extern "C" vtkBezierHexahedron * vtkBezierHexahedron_new () ; +extern "C" void vtkBezierHexahedron_destructor (vtkBezierHexahedron * sself) ; +extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkBezierHexahedron* sself); +extern "C" vtkBezierInterpolation * vtkBezierInterpolation_new () ; +extern "C" void vtkBezierInterpolation_destructor (vtkBezierInterpolation * sself) ; +extern "C" vtkBezierQuadrilateral * vtkBezierQuadrilateral_new () ; +extern "C" void vtkBezierQuadrilateral_destructor (vtkBezierQuadrilateral * sself) ; +extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkBezierQuadrilateral* sself); +extern "C" vtkBezierTetra * vtkBezierTetra_new () ; +extern "C" void vtkBezierTetra_destructor (vtkBezierTetra * sself) ; +extern "C" int vtk_bezier_tetra_get_cell_type(vtkBezierTetra* sself); +extern "C" vtkBezierTriangle * vtkBezierTriangle_new () ; +extern "C" void vtkBezierTriangle_destructor (vtkBezierTriangle * sself) ; +extern "C" int vtk_bezier_triangle_get_cell_type(vtkBezierTriangle* sself); +extern "C" vtkBezierWedge * vtkBezierWedge_new () ; +extern "C" void vtkBezierWedge_destructor (vtkBezierWedge * sself) ; +extern "C" int vtk_bezier_wedge_get_cell_type(vtkBezierWedge* sself); +extern "C" vtkBiQuadraticQuad * vtkBiQuadraticQuad_new () ; +extern "C" void vtkBiQuadraticQuad_destructor (vtkBiQuadraticQuad * sself) ; +extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkBiQuadraticQuad* sself); +extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkBiQuadraticQuad* sself); +extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkBiQuadraticQuad* sself); +extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkBiQuadraticQuad* sself); +extern "C" vtkBiQuadraticQuadraticHexahedron * vtkBiQuadraticQuadraticHexahedron_new () ; +extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkBiQuadraticQuadraticHexahedron * sself) ; +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkBiQuadraticQuadraticHexahedron* sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkBiQuadraticQuadraticHexahedron* sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkBiQuadraticQuadraticHexahedron* sself); +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkBiQuadraticQuadraticHexahedron* sself); +extern "C" vtkBiQuadraticQuadraticWedge * vtkBiQuadraticQuadraticWedge_new () ; +extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkBiQuadraticQuadraticWedge * sself) ; +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkBiQuadraticQuadraticWedge* sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkBiQuadraticQuadraticWedge* sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkBiQuadraticQuadraticWedge* sself); +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkBiQuadraticQuadraticWedge* sself); +extern "C" vtkBiQuadraticTriangle * vtkBiQuadraticTriangle_new () ; +extern "C" void vtkBiQuadraticTriangle_destructor (vtkBiQuadraticTriangle * sself) ; +extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkBiQuadraticTriangle* sself); +extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkBiQuadraticTriangle* sself); +extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkBiQuadraticTriangle* sself); +extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkBiQuadraticTriangle* sself); +extern "C" vtkBox * vtkBox_new () ; +extern "C" void vtkBox_destructor (vtkBox * sself) ; +extern "C" void vtk_box_set_x_min(vtkBox* sself, double x, double y, double z); +extern "C" void vtk_box_get_x_min(vtkBox* sself, double& x, double& y, double& z); +extern "C" void vtk_box_set_x_max(vtkBox* sself, double x, double y, double z); +extern "C" void vtk_box_get_x_max(vtkBox* sself, double& x, double& y, double& z); +extern "C" void vtk_box_set_bounds(vtkBox* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_box_get_bounds(vtkBox* sself, double& xMin, double& xMax, double& yMin, double& yMax, double& zMin, double& zMax); +extern "C" vtkCellArray * vtkCellArray_new () ; +extern "C" void vtkCellArray_destructor (vtkCellArray * sself) ; +extern "C" int vtk_cell_array_allocate(vtkCellArray* sself, long long sz, long long ext); +extern "C" bool vtk_cell_array_allocate_estimate(vtkCellArray* sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_cell_array_allocate_exact(vtkCellArray* sself, long long numCells, long long connectivitySize); +extern "C" bool vtk_cell_array_resize_exact(vtkCellArray* sself, long long numCells, long long connectivitySize); +extern "C" void vtk_cell_array_initialize(vtkCellArray* sself); +extern "C" void vtk_cell_array_reset(vtkCellArray* sself); +extern "C" void vtk_cell_array_squeeze(vtkCellArray* sself); +extern "C" bool vtk_cell_array_is_valid(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_number_of_cells(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_number_of_offsets(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_number_of_connectivity_ids(vtkCellArray* sself); +extern "C" bool vtk_cell_array_is_storage_64_bit(vtkCellArray* sself); +extern "C" bool vtk_cell_array_is_storage_shareable(vtkCellArray* sself); +extern "C" void vtk_cell_array_use_32_bit_storage(vtkCellArray* sself); +extern "C" void vtk_cell_array_use_64_bit_storage(vtkCellArray* sself); +extern "C" void vtk_cell_array_use_default_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_can_convert_to_32_bit_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_can_convert_to_64_bit_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_can_convert_to_default_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_convert_to_32_bit_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_convert_to_64_bit_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_convert_to_default_storage(vtkCellArray* sself); +extern "C" bool vtk_cell_array_convert_to_smallest_storage(vtkCellArray* sself); +extern "C" long long vtk_cell_array_is_homogeneous(vtkCellArray* sself); +extern "C" void vtk_cell_array_init_traversal(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_cell_size(vtkCellArray* sself, const long long cellId); +extern "C" void vtk_cell_array_insert_cell_point(vtkCellArray* sself, long long id); +extern "C" void vtk_cell_array_update_cell_count(vtkCellArray* sself, int npts); +extern "C" long long vtk_cell_array_get_traversal_cell_id(vtkCellArray* sself); +extern "C" void vtk_cell_array_set_traversal_cell_id(vtkCellArray* sself, long long cellId); +extern "C" void vtk_cell_array_reverse_cell_at_id(vtkCellArray* sself, long long cellId); +extern "C" int vtk_cell_array_get_max_cell_size(vtkCellArray* sself); +extern "C" unsigned long vtk_cell_array_get_actual_memory_size(vtkCellArray* sself); +extern "C" void vtk_cell_array_set_number_of_cells(vtkCellArray* sself, long long p0); +extern "C" long long vtk_cell_array_estimate_size(vtkCellArray* sself, long long numCells, int maxPtsPerCell); +extern "C" long long vtk_cell_array_get_size(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_number_of_connectivity_entries(vtkCellArray* sself); +extern "C" long long vtk_cell_array_get_insert_location(vtkCellArray* sself, int npts); +extern "C" long long vtk_cell_array_get_traversal_location(vtkCellArray* sself); +extern "C" void vtk_cell_array_set_traversal_location(vtkCellArray* sself, long long loc); +extern "C" void vtk_cell_array_reverse_cell(vtkCellArray* sself, long long loc); +extern "C" vtkCellArrayIterator * vtkCellArrayIterator_new () ; +extern "C" void vtkCellArrayIterator_destructor (vtkCellArrayIterator * sself) ; +extern "C" void vtk_cell_array_iterator_go_to_cell(vtkCellArrayIterator* sself, long long cellId); +extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkCellArrayIterator* sself); +extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkCellArrayIterator* sself); +extern "C" bool vtk_cell_array_iterator_is_done_with_traversal(vtkCellArrayIterator* sself); +extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkCellArrayIterator* sself); +extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkCellArrayIterator* sself); +extern "C" vtkCellData * vtkCellData_new () ; +extern "C" void vtkCellData_destructor (vtkCellData * sself) ; +extern "C" vtkCellLinks * vtkCellLinks_new () ; +extern "C" void vtkCellLinks_destructor (vtkCellLinks * sself) ; +extern "C" void vtk_cell_links_allocate(vtkCellLinks* sself, long long numLinks, long long ext); +extern "C" void vtk_cell_links_initialize(vtkCellLinks* sself); +extern "C" long long vtk_cell_links_get_ncells(vtkCellLinks* sself, long long ptId); +extern "C" long long vtk_cell_links_insert_next_point(vtkCellLinks* sself, int numLinks); +extern "C" void vtk_cell_links_insert_next_cell_reference(vtkCellLinks* sself, long long ptId, long long cellId); +extern "C" void vtk_cell_links_delete_point(vtkCellLinks* sself, long long ptId); +extern "C" void vtk_cell_links_remove_cell_reference(vtkCellLinks* sself, long long cellId, long long ptId); +extern "C" void vtk_cell_links_add_cell_reference(vtkCellLinks* sself, long long cellId, long long ptId); +extern "C" void vtk_cell_links_resize_cell_list(vtkCellLinks* sself, long long ptId, int size); +extern "C" void vtk_cell_links_squeeze(vtkCellLinks* sself); +extern "C" void vtk_cell_links_reset(vtkCellLinks* sself); +extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkCellLinks* sself); +extern "C" vtkCellLocator * vtkCellLocator_new () ; +extern "C" void vtkCellLocator_destructor (vtkCellLocator * sself) ; +extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkCellLocator* sself, int N); +extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkCellLocator* sself); +extern "C" int vtk_cell_locator_get_number_of_buckets(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_free_search_structure(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_build_locator(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_build_locator_if_needed(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_force_build_locator(vtkCellLocator* sself); +extern "C" void vtk_cell_locator_build_locator_internal(vtkCellLocator* sself); +extern "C" vtkCellLocatorStrategy * vtkCellLocatorStrategy_new () ; +extern "C" void vtkCellLocatorStrategy_destructor (vtkCellLocatorStrategy * sself) ; +extern "C" vtkCellTypes * vtkCellTypes_new () ; +extern "C" void vtkCellTypes_destructor (vtkCellTypes * sself) ; +extern "C" int vtk_cell_types_allocate(vtkCellTypes* sself, long long sz, long long ext); +extern "C" void vtk_cell_types_insert_cell(vtkCellTypes* sself, long long id, unsigned char type, long long loc); +extern "C" long long vtk_cell_types_insert_next_cell(vtkCellTypes* sself, unsigned char type, long long loc); +extern "C" long long vtk_cell_types_get_cell_location(vtkCellTypes* sself, long long cellId); +extern "C" void vtk_cell_types_delete_cell(vtkCellTypes* sself, long long cellId); +extern "C" long long vtk_cell_types_get_number_of_types(vtkCellTypes* sself); +extern "C" int vtk_cell_types_is_type(vtkCellTypes* sself, unsigned char type); +extern "C" long long vtk_cell_types_insert_next_type(vtkCellTypes* sself, unsigned char type); +extern "C" unsigned char vtk_cell_types_get_cell_type(vtkCellTypes* sself, long long cellId); +extern "C" void vtk_cell_types_squeeze(vtkCellTypes* sself); +extern "C" void vtk_cell_types_reset(vtkCellTypes* sself); +extern "C" unsigned long vtk_cell_types_get_actual_memory_size(vtkCellTypes* sself); +extern "C" const char* vtk_cell_types_get_class_name_from_type_id(vtkCellTypes* sself, int typeId); +extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkCellTypes* sself, const char* classname); +extern "C" int vtk_cell_types_is_linear(vtkCellTypes* sself, unsigned char type); +extern "C" vtkClosestNPointsStrategy * vtkClosestNPointsStrategy_new () ; +extern "C" void vtkClosestNPointsStrategy_destructor (vtkClosestNPointsStrategy * sself) ; +extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkClosestNPointsStrategy* sself, int _arg); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkClosestNPointsStrategy* sself); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkClosestNPointsStrategy* sself); +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkClosestNPointsStrategy* sself); +extern "C" vtkClosestPointStrategy * vtkClosestPointStrategy_new () ; +extern "C" void vtkClosestPointStrategy_destructor (vtkClosestPointStrategy * sself) ; +extern "C" vtkCone * vtkCone_new () ; +extern "C" void vtkCone_destructor (vtkCone * sself) ; +extern "C" void vtk_cone_set_angle(vtkCone* sself, double _arg); +extern "C" double vtk_cone_get_angle_min_value(vtkCone* sself); +extern "C" double vtk_cone_get_angle_max_value(vtkCone* sself); +extern "C" double vtk_cone_get_angle(vtkCone* sself); +extern "C" vtkConvexPointSet * vtkConvexPointSet_new () ; +extern "C" void vtkConvexPointSet_destructor (vtkConvexPointSet * sself) ; +extern "C" int vtk_convex_point_set_has_fixed_topology(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_get_cell_type(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_requires_initialization(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_get_number_of_edges(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_get_number_of_faces(vtkConvexPointSet* sself); +extern "C" int vtk_convex_point_set_is_primary_cell(vtkConvexPointSet* sself); +extern "C" vtkCubicLine * vtkCubicLine_new () ; +extern "C" void vtkCubicLine_destructor (vtkCubicLine * sself) ; +extern "C" int vtk_cubic_line_get_cell_type(vtkCubicLine* sself); +extern "C" int vtk_cubic_line_get_cell_dimension(vtkCubicLine* sself); +extern "C" int vtk_cubic_line_get_number_of_edges(vtkCubicLine* sself); +extern "C" int vtk_cubic_line_get_number_of_faces(vtkCubicLine* sself); +extern "C" vtkCylinder * vtkCylinder_new () ; +extern "C" void vtkCylinder_destructor (vtkCylinder * sself) ; +extern "C" void vtk_cylinder_set_radius(vtkCylinder* sself, double _arg); +extern "C" double vtk_cylinder_get_radius(vtkCylinder* sself); +extern "C" void vtk_cylinder_set_center(vtkCylinder* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cylinder_set_axis(vtkCylinder* sself, double ax, double ay, double az); +extern "C" vtkDataAssembly * vtkDataAssembly_new () ; +extern "C" void vtkDataAssembly_destructor (vtkDataAssembly * sself) ; +extern "C" void vtk_data_assembly_initialize(vtkDataAssembly* sself); +extern "C" bool vtk_data_assembly_initialize_from_xml(vtkDataAssembly* sself, const char* xmlcontents); +extern "C" int vtk_data_assembly_get_root_node(vtkDataAssembly* sself); +extern "C" void vtk_data_assembly_set_root_node_name(vtkDataAssembly* sself, const char* name); +extern "C" const char* vtk_data_assembly_get_root_node_name(vtkDataAssembly* sself); +extern "C" int vtk_data_assembly_add_node(vtkDataAssembly* sself, const char* name, int parent); +extern "C" bool vtk_data_assembly_remove_node(vtkDataAssembly* sself, int id); +extern "C" void vtk_data_assembly_set_node_name(vtkDataAssembly* sself, int id, const char* name); +extern "C" const char* vtk_data_assembly_get_node_name(vtkDataAssembly* sself, int id); +extern "C" int vtk_data_assembly_get_first_node_by_path(vtkDataAssembly* sself, const char* path); +extern "C" bool vtk_data_assembly_add_data_set_index(vtkDataAssembly* sself, int id, unsigned int dataset_index); +extern "C" bool vtk_data_assembly_add_data_set_index_range(vtkDataAssembly* sself, int id, unsigned int index_start, int count); +extern "C" bool vtk_data_assembly_remove_data_set_index(vtkDataAssembly* sself, int id, unsigned int dataset_index); +extern "C" bool vtk_data_assembly_remove_all_data_set_indices(vtkDataAssembly* sself, int id, bool traverse_subtree); +extern "C" int vtk_data_assembly_find_first_node_with_name(vtkDataAssembly* sself, const char* name, int traversal_order); +extern "C" int vtk_data_assembly_get_number_of_children(vtkDataAssembly* sself, int parent); +extern "C" int vtk_data_assembly_get_child(vtkDataAssembly* sself, int parent, int index); +extern "C" int vtk_data_assembly_get_child_index(vtkDataAssembly* sself, int parent, int child); +extern "C" int vtk_data_assembly_get_parent(vtkDataAssembly* sself, int id); +extern "C" bool vtk_data_assembly_has_attribute(vtkDataAssembly* sself, int id, const char* name); +extern "C" void vtk_data_assembly_set_attribute(vtkDataAssembly* sself, int id, const char* name, const char* value); +extern "C" bool vtk_data_assembly_get_attribute(vtkDataAssembly* sself, int id, const char* name, const char* value); +extern "C" const char* vtk_data_assembly_get_attribute_or_default(vtkDataAssembly* sself, int id, const char* name, const char* default_value); +extern "C" bool vtk_data_assembly_is_node_name_valid(vtkDataAssembly* sself, const char* name); +extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkDataAssembly* sself, const char* name); +extern "C" vtkDataAssemblyUtilities * vtkDataAssemblyUtilities_new () ; +extern "C" void vtkDataAssemblyUtilities_destructor (vtkDataAssemblyUtilities * sself) ; +extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkDataAssemblyUtilities* sself); +extern "C" vtkDataObject * vtkDataObject_new () ; +extern "C" void vtkDataObject_destructor (vtkDataObject * sself) ; +extern "C" unsigned long vtk_data_object_get_m_time(vtkDataObject* sself); +extern "C" void vtk_data_object_initialize(vtkDataObject* sself); +extern "C" void vtk_data_object_release_data(vtkDataObject* sself); +extern "C" int vtk_data_object_get_data_released(vtkDataObject* sself); +extern "C" void vtk_data_object_set_global_release_data_flag(vtkDataObject* sself, int val); +extern "C" void vtk_data_object_global_release_data_flag_on(vtkDataObject* sself); +extern "C" void vtk_data_object_global_release_data_flag_off(vtkDataObject* sself); +extern "C" int vtk_data_object_get_global_release_data_flag(vtkDataObject* sself); +extern "C" int vtk_data_object_get_data_object_type(vtkDataObject* sself); +extern "C" unsigned long vtk_data_object_get_update_time(vtkDataObject* sself); +extern "C" unsigned long vtk_data_object_get_actual_memory_size(vtkDataObject* sself); +extern "C" void vtk_data_object_data_has_been_generated(vtkDataObject* sself); +extern "C" void vtk_data_object_prepare_for_new_data(vtkDataObject* sself); +extern "C" int vtk_data_object_get_extent_type(vtkDataObject* sself); +extern "C" long long vtk_data_object_get_number_of_elements(vtkDataObject* sself, int type); +extern "C" const char* vtk_data_object_get_association_type_as_string(vtkDataObject* sself, int associationType); +extern "C" int vtk_data_object_get_association_type_from_string(vtkDataObject* sself, const char* associationName); +extern "C" vtkDataObjectCollection * vtkDataObjectCollection_new () ; +extern "C" void vtkDataObjectCollection_destructor (vtkDataObjectCollection * sself) ; +extern "C" int vtk_data_object_collection_get_number_of_items(vtkDataObjectCollection* sself); +extern "C" vtkDataObjectTreeIterator * vtkDataObjectTreeIterator_new () ; +extern "C" void vtkDataObjectTreeIterator_destructor (vtkDataObjectTreeIterator * sself) ; +extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkDataObjectTreeIterator* sself); +extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkDataObjectTreeIterator* sself); +extern "C" int vtk_data_object_tree_iterator_has_current_meta_data(vtkDataObjectTreeIterator* sself); +extern "C" unsigned int vtk_data_object_tree_iterator_get_current_flat_index(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_set_visit_only_leaves(vtkDataObjectTreeIterator* sself, int _arg); +extern "C" int vtk_data_object_tree_iterator_get_visit_only_leaves(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_on(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_off(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_set_traverse_sub_tree(vtkDataObjectTreeIterator* sself, int _arg); +extern "C" int vtk_data_object_tree_iterator_get_traverse_sub_tree(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkDataObjectTreeIterator* sself); +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkDataObjectTreeIterator* sself); +extern "C" vtkDataObjectTypes * vtkDataObjectTypes_new () ; +extern "C" void vtkDataObjectTypes_destructor (vtkDataObjectTypes * sself) ; +extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkDataObjectTypes* sself, int typeId); +extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkDataObjectTypes* sself, const char* classname); +extern "C" bool vtk_data_object_types_type_id_is_a(vtkDataObjectTypes* sself, int typeId, int targetTypeId); +extern "C" int vtk_data_object_types_get_common_base_type_id(vtkDataObjectTypes* sself, int typeA, int typeB); +extern "C" vtkDataSetAttributes * vtkDataSetAttributes_new () ; +extern "C" void vtkDataSetAttributes_destructor (vtkDataSetAttributes * sself) ; +extern "C" void vtk_data_set_attributes_initialize(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_update(vtkDataSetAttributes* sself); +extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkDataSetAttributes* sself); +extern "C" int vtk_data_set_attributes_set_active_scalars(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_vectors(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_normals(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_tangents(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_t_coords(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_tensors(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_global_ids(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_pedigree_ids(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_rational_weights(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_higher_order_degrees(vtkDataSetAttributes* sself, const char* name); +extern "C" int vtk_data_set_attributes_set_active_attribute(vtkDataSetAttributes* sself, const char* name, int attributeType); +extern "C" int vtk_data_set_attributes_is_array_an_attribute(vtkDataSetAttributes* sself, int idx); +extern "C" const char* vtk_data_set_attributes_get_attribute_type_as_string(vtkDataSetAttributes* sself, int attributeType); +extern "C" const char* vtk_data_set_attributes_get_long_attribute_type_as_string(vtkDataSetAttributes* sself, int attributeType); +extern "C" void vtk_data_set_attributes_set_copy_attribute(vtkDataSetAttributes* sself, int index, int value, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_attribute(vtkDataSetAttributes* sself, int index, int ctype); +extern "C" void vtk_data_set_attributes_set_copy_scalars(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_scalars(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_scalars_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_scalars_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_vectors(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_vectors(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_vectors_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_vectors_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_normals(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_normals(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_normals_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_normals_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_tangents(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_tangents(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_tangents_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_tangents_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_t_coords(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_t_coords(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_t_coords_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_t_coords_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_tensors(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_tensors(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_tensors_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_tensors_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_global_ids(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_global_ids(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_global_ids_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_global_ids_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_pedigree_ids(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_pedigree_ids(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_rational_weights(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_rational_weights(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_rational_weights_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_rational_weights_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_set_copy_higher_order_degrees(vtkDataSetAttributes* sself, int i, int ctype); +extern "C" int vtk_data_set_attributes_get_copy_higher_order_degrees(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_on(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_off(vtkDataSetAttributes* sself); +extern "C" void vtk_data_set_attributes_copy_all_on(vtkDataSetAttributes* sself, int ctype); +extern "C" void vtk_data_set_attributes_copy_all_off(vtkDataSetAttributes* sself, int ctype); +extern "C" vtkDataSetCellIterator * vtkDataSetCellIterator_new () ; +extern "C" void vtkDataSetCellIterator_destructor (vtkDataSetCellIterator * sself) ; +extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkDataSetCellIterator* sself); +extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkDataSetCellIterator* sself); +extern "C" vtkDataSetCollection * vtkDataSetCollection_new () ; +extern "C" void vtkDataSetCollection_destructor (vtkDataSetCollection * sself) ; +extern "C" int vtk_data_set_collection_get_number_of_items(vtkDataSetCollection* sself); +extern "C" vtkDirectedAcyclicGraph * vtkDirectedAcyclicGraph_new () ; +extern "C" void vtkDirectedAcyclicGraph_destructor (vtkDirectedAcyclicGraph * sself) ; +extern "C" vtkDirectedGraph * vtkDirectedGraph_new () ; +extern "C" void vtkDirectedGraph_destructor (vtkDirectedGraph * sself) ; +extern "C" vtkEdgeListIterator * vtkEdgeListIterator_new () ; +extern "C" void vtkEdgeListIterator_destructor (vtkEdgeListIterator * sself) ; +extern "C" bool vtk_edge_list_iterator_has_next(vtkEdgeListIterator* sself); +extern "C" vtkEdgeTable * vtkEdgeTable_new () ; +extern "C" void vtkEdgeTable_destructor (vtkEdgeTable * sself) ; +extern "C" void vtk_edge_table_initialize(vtkEdgeTable* sself); +extern "C" int vtk_edge_table_init_edge_insertion(vtkEdgeTable* sself, long long numPoints, int storeAttributes); +extern "C" long long vtk_edge_table_insert_edge(vtkEdgeTable* sself, long long p1, long long p2); +extern "C" long long vtk_edge_table_is_edge(vtkEdgeTable* sself, long long p1, long long p2); +extern "C" long long vtk_edge_table_get_number_of_edges(vtkEdgeTable* sself); +extern "C" void vtk_edge_table_init_traversal(vtkEdgeTable* sself); +extern "C" long long vtk_edge_table_get_next_edge(vtkEdgeTable* sself, long long& p1, long long& p2); +extern "C" void vtk_edge_table_reset(vtkEdgeTable* sself); +extern "C" vtkEmptyCell * vtkEmptyCell_new () ; +extern "C" void vtkEmptyCell_destructor (vtkEmptyCell * sself) ; +extern "C" int vtk_empty_cell_get_cell_type(vtkEmptyCell* sself); +extern "C" int vtk_empty_cell_get_cell_dimension(vtkEmptyCell* sself); +extern "C" int vtk_empty_cell_get_number_of_edges(vtkEmptyCell* sself); +extern "C" int vtk_empty_cell_get_number_of_faces(vtkEmptyCell* sself); +extern "C" vtkExplicitStructuredGrid * vtkExplicitStructuredGrid_new () ; +extern "C" void vtkExplicitStructuredGrid_destructor (vtkExplicitStructuredGrid * sself) ; +extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_initialize(vtkExplicitStructuredGrid* sself); +extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" int vtk_explicit_structured_grid_get_data_dimension(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkExplicitStructuredGrid* sself, int i, int j, int k); +extern "C" int vtk_explicit_structured_grid_get_extent_type(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_set_extent(vtkExplicitStructuredGrid* sself, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_explicit_structured_grid_build_links(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_compute_cell_structured_coords(vtkExplicitStructuredGrid* sself, long long cellId, int& i, int& j, int& k, bool adjustForExtent); +extern "C" long long vtk_explicit_structured_grid_compute_cell_id(vtkExplicitStructuredGrid* sself, int i, int j, int k, bool adjustForExtent); +extern "C" void vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name(vtkExplicitStructuredGrid* sself, const char* _arg); +extern "C" void vtk_explicit_structured_grid_blank_cell(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" void vtk_explicit_structured_grid_un_blank_cell(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" bool vtk_explicit_structured_grid_has_any_blank_cells(vtkExplicitStructuredGrid* sself); +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_visible(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_ghost(vtkExplicitStructuredGrid* sself, long long cellId); +extern "C" bool vtk_explicit_structured_grid_has_any_ghost_cells(vtkExplicitStructuredGrid* sself); +extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtkExplicitStructuredGrid* sself); +extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkExplicitStructuredGrid* sself); +extern "C" vtkExtractStructuredGridHelper * vtkExtractStructuredGridHelper_new () ; +extern "C" void vtkExtractStructuredGridHelper_destructor (vtkExtractStructuredGridHelper * sself) ; +extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkExtractStructuredGridHelper* sself); +extern "C" int vtk_extract_structured_grid_helper_get_size(vtkExtractStructuredGridHelper* sself, const int dim); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value(vtkExtractStructuredGridHelper* sself, int dim, int outExtVal); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkExtractStructuredGridHelper* sself, int dim, int outExtVal); +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx); +extern "C" vtkFieldData * vtkFieldData_new () ; +extern "C" void vtkFieldData_destructor (vtkFieldData * sself) ; +extern "C" void vtk_field_data_initialize(vtkFieldData* sself); +extern "C" int vtk_field_data_allocate(vtkFieldData* sself, long long sz, long long ext); +extern "C" void vtk_field_data_allocate_arrays(vtkFieldData* sself, int num); +extern "C" int vtk_field_data_get_number_of_arrays(vtkFieldData* sself); +extern "C" void vtk_field_data_null_data(vtkFieldData* sself, long long id); +extern "C" void vtk_field_data_remove_array(vtkFieldData* sself, const char* name); +extern "C" int vtk_field_data_has_array(vtkFieldData* sself, const char* name); +extern "C" const char* vtk_field_data_get_array_name(vtkFieldData* sself, int i); +extern "C" void vtk_field_data_copy_field_on(vtkFieldData* sself, const char* name); +extern "C" void vtk_field_data_copy_field_off(vtkFieldData* sself, const char* name); +extern "C" void vtk_field_data_copy_all_on(vtkFieldData* sself, int unused); +extern "C" void vtk_field_data_copy_all_off(vtkFieldData* sself, int unused); +extern "C" void vtk_field_data_squeeze(vtkFieldData* sself); +extern "C" void vtk_field_data_reset(vtkFieldData* sself); +extern "C" unsigned long vtk_field_data_get_actual_memory_size(vtkFieldData* sself); +extern "C" unsigned long vtk_field_data_get_m_time(vtkFieldData* sself); +extern "C" int vtk_field_data_get_array_containing_component(vtkFieldData* sself, int i, int& arrayComp); +extern "C" int vtk_field_data_get_number_of_components(vtkFieldData* sself); +extern "C" long long vtk_field_data_get_number_of_tuples(vtkFieldData* sself); +extern "C" void vtk_field_data_set_number_of_tuples(vtkFieldData* sself, const long long number); +extern "C" vtkGenericAttributeCollection * vtkGenericAttributeCollection_new () ; +extern "C" void vtkGenericAttributeCollection_destructor (vtkGenericAttributeCollection * sself) ; +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_max_number_of_components(vtkGenericAttributeCollection* sself); +extern "C" unsigned long vtk_generic_attribute_collection_get_actual_memory_size(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_is_empty(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_find_attribute(vtkGenericAttributeCollection* sself, const char* name); +extern "C" int vtk_generic_attribute_collection_get_attribute_index(vtkGenericAttributeCollection* sself, int i); +extern "C" void vtk_generic_attribute_collection_remove_attribute(vtkGenericAttributeCollection* sself, int i); +extern "C" void vtk_generic_attribute_collection_reset(vtkGenericAttributeCollection* sself); +extern "C" unsigned long vtk_generic_attribute_collection_get_m_time(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_active_attribute(vtkGenericAttributeCollection* sself); +extern "C" int vtk_generic_attribute_collection_get_active_component(vtkGenericAttributeCollection* sself); +extern "C" void vtk_generic_attribute_collection_set_active_attribute(vtkGenericAttributeCollection* sself, int attribute, int component); +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate(vtkGenericAttributeCollection* sself); +extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkGenericAttributeCollection* sself); +extern "C" vtkGenericCell * vtkGenericCell_new () ; +extern "C" void vtkGenericCell_destructor (vtkGenericCell * sself) ; +extern "C" int vtk_generic_cell_get_cell_type(vtkGenericCell* sself); +extern "C" int vtk_generic_cell_get_cell_dimension(vtkGenericCell* sself); +extern "C" int vtk_generic_cell_get_number_of_edges(vtkGenericCell* sself); +extern "C" int vtk_generic_cell_get_number_of_faces(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type(vtkGenericCell* sself, int cellType); +extern "C" void vtk_generic_cell_set_cell_type_to_empty_cell(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_vertex(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_poly_vertex(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_line(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_poly_line(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_triangle_strip(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_polygon(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pixel(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quad(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tetra(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_voxel(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pyramid(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_pentagonal_prism(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_hexagonal_prism(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_polyhedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_convex_point_set(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_edge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_cubic_line(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_quad(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_polygon(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_tetra(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_pyramid(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_tetra(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_curve(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_wedge(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_triangle(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_tetra(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_curve(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkGenericCell* sself); +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkGenericCell* sself); +extern "C" vtkGenericEdgeTable * vtkGenericEdgeTable_new () ; +extern "C" void vtkGenericEdgeTable_destructor (vtkGenericEdgeTable * sself) ; +extern "C" void vtk_generic_edge_table_insert_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId, int ref, long long& ptId); +extern "C" int vtk_generic_edge_table_remove_edge(vtkGenericEdgeTable* sself, long long e1, long long e2); +extern "C" int vtk_generic_edge_table_check_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long& ptId); +extern "C" int vtk_generic_edge_table_increment_edge_reference_count(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId); +extern "C" int vtk_generic_edge_table_check_edge_reference_count(vtkGenericEdgeTable* sself, long long e1, long long e2); +extern "C" void vtk_generic_edge_table_initialize(vtkGenericEdgeTable* sself, long long start); +extern "C" int vtk_generic_edge_table_get_number_of_components(vtkGenericEdgeTable* sself); +extern "C" void vtk_generic_edge_table_set_number_of_components(vtkGenericEdgeTable* sself, int count); +extern "C" int vtk_generic_edge_table_check_point(vtkGenericEdgeTable* sself, long long ptId); +extern "C" void vtk_generic_edge_table_remove_point(vtkGenericEdgeTable* sself, long long ptId); +extern "C" void vtk_generic_edge_table_increment_point_reference_count(vtkGenericEdgeTable* sself, long long ptId); +extern "C" void vtk_generic_edge_table_dump_table(vtkGenericEdgeTable* sself); +extern "C" void vtk_generic_edge_table_load_factor(vtkGenericEdgeTable* sself); +extern "C" vtkGenericInterpolatedVelocityField * vtkGenericInterpolatedVelocityField_new () ; +extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkGenericInterpolatedVelocityField * sself) ; +extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkGenericInterpolatedVelocityField* sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkGenericInterpolatedVelocityField* sself); +extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkGenericInterpolatedVelocityField* sself, int _arg); +extern "C" void vtk_generic_interpolated_velocity_field_caching_on(vtkGenericInterpolatedVelocityField* sself); +extern "C" void vtk_generic_interpolated_velocity_field_caching_off(vtkGenericInterpolatedVelocityField* sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_hit(vtkGenericInterpolatedVelocityField* sself); +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkGenericInterpolatedVelocityField* sself); +extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkGenericInterpolatedVelocityField* sself, const char* fieldName); +extern "C" vtkGeometricErrorMetric * vtkGeometricErrorMetric_new () ; +extern "C" void vtkGeometricErrorMetric_destructor (vtkGeometricErrorMetric * sself) ; +extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself); +extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself, double value); +extern "C" int vtk_geometric_error_metric_get_relative(vtkGeometricErrorMetric* sself); +extern "C" vtkGraphEdge * vtkGraphEdge_new () ; +extern "C" void vtkGraphEdge_destructor (vtkGraphEdge * sself) ; +extern "C" void vtk_graph_edge_set_source(vtkGraphEdge* sself, long long _arg); +extern "C" long long vtk_graph_edge_get_source(vtkGraphEdge* sself); +extern "C" void vtk_graph_edge_set_target(vtkGraphEdge* sself, long long _arg); +extern "C" long long vtk_graph_edge_get_target(vtkGraphEdge* sself); +extern "C" void vtk_graph_edge_set_id(vtkGraphEdge* sself, long long _arg); +extern "C" long long vtk_graph_edge_get_id(vtkGraphEdge* sself); +extern "C" vtkGraphInternals * vtkGraphInternals_new () ; +extern "C" void vtkGraphInternals_destructor (vtkGraphInternals * sself) ; +extern "C" vtkHexagonalPrism * vtkHexagonalPrism_new () ; +extern "C" void vtkHexagonalPrism_destructor (vtkHexagonalPrism * sself) ; +extern "C" int vtk_hexagonal_prism_get_cell_type(vtkHexagonalPrism* sself); +extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkHexagonalPrism* sself); +extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkHexagonalPrism* sself); +extern "C" vtkHexahedron * vtkHexahedron_new () ; +extern "C" void vtkHexahedron_destructor (vtkHexahedron * sself) ; +extern "C" int vtk_hexahedron_get_cell_type(vtkHexahedron* sself); +extern "C" int vtk_hexahedron_get_number_of_edges(vtkHexahedron* sself); +extern "C" int vtk_hexahedron_get_number_of_faces(vtkHexahedron* sself); +extern "C" vtkHierarchicalBoxDataIterator * vtkHierarchicalBoxDataIterator_new () ; +extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkHierarchicalBoxDataIterator * sself) ; +extern "C" vtkHierarchicalBoxDataSet * vtkHierarchicalBoxDataSet_new () ; +extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkHierarchicalBoxDataSet * sself) ; +extern "C" vtkHyperTreeGrid * vtkHyperTreeGrid_new () ; +extern "C" void vtkHyperTreeGrid_destructor (vtkHyperTreeGrid * sself) ; +extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkHyperTreeGrid* sself, const char* _arg); +extern "C" void vtk_hyper_tree_grid_squeeze(vtkHyperTreeGrid* sself); +extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkHyperTreeGrid* sself, unsigned int i, unsigned int j, unsigned int k); +extern "C" void vtk_hyper_tree_grid_set_extent(vtkHyperTreeGrid* sself, int x1, int x2, int y1, int y2, int z1, int z2); +extern "C" unsigned int vtk_hyper_tree_grid_get_dimension(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_get_1_d_axis(vtkHyperTreeGrid* sself, unsigned int& axis); +extern "C" void vtk_hyper_tree_grid_get_2_d_axes(vtkHyperTreeGrid* sself, unsigned int& axis1, unsigned int& axis2); +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_children(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_transposed_root_indexing(vtkHyperTreeGrid* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_get_transposed_root_indexing(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_kji(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_ijk(vtkHyperTreeGrid* sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_orientation(vtkHyperTreeGrid* sself); +extern "C" bool vtk_hyper_tree_grid_get_freeze_state(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_branch_factor(vtkHyperTreeGrid* sself, unsigned int p0); +extern "C" unsigned int vtk_hyper_tree_grid_get_branch_factor(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_max_number_of_trees(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_vertices(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_non_empty_trees(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_leaves(vtkHyperTreeGrid* sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkHyperTreeGrid* sself, long long p0); +extern "C" void vtk_hyper_tree_grid_set_fixed_coordinates(vtkHyperTreeGrid* sself, unsigned int axis, double value); +extern "C" bool vtk_hyper_tree_grid_has_mask(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_has_interface(vtkHyperTreeGrid* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_get_has_interface(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_has_interface_on(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_has_interface_off(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_set_interface_normals_name(vtkHyperTreeGrid* sself, const char* _arg); +extern "C" void vtk_hyper_tree_grid_set_interface_intercepts_name(vtkHyperTreeGrid* sself, const char* _arg); +extern "C" void vtk_hyper_tree_grid_set_depth_limiter(vtkHyperTreeGrid* sself, unsigned int _arg); +extern "C" unsigned int vtk_hyper_tree_grid_get_depth_limiter(vtkHyperTreeGrid* sself); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_x(vtkHyperTreeGrid* sself, double value); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_y(vtkHyperTreeGrid* sself, double value); +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_z(vtkHyperTreeGrid* sself, double value); +extern "C" void vtk_hyper_tree_grid_initialize(vtkHyperTreeGrid* sself); +extern "C" int vtk_hyper_tree_grid_get_extent_type(vtkHyperTreeGrid* sself); +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size_bytes(vtkHyperTreeGrid* sself); +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size(vtkHyperTreeGrid* sself); +extern "C" unsigned int vtk_hyper_tree_grid_get_child_mask(vtkHyperTreeGrid* sself, unsigned int p0); +extern "C" void vtk_hyper_tree_grid_get_index_from_level_zero_coordinates(vtkHyperTreeGrid* sself, long long& p0, unsigned int p1, unsigned int p2, unsigned int p3); +extern "C" long long vtk_hyper_tree_grid_get_shifted_level_zero_index(vtkHyperTreeGrid* sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3); +extern "C" void vtk_hyper_tree_grid_get_level_zero_coordinates_from_index(vtkHyperTreeGrid* sself, long long p0, unsigned int& p1, unsigned int& p2, unsigned int& p3); +extern "C" long long vtk_hyper_tree_grid_get_global_node_index_max(vtkHyperTreeGrid* sself); +extern "C" void vtk_hyper_tree_grid_initialize_local_index_node(vtkHyperTreeGrid* sself); +extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkHyperTreeGrid* sself); +extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkHyperTreeGrid* sself, int type); +extern "C" vtkHyperTreeGridNonOrientedCursor * vtkHyperTreeGridNonOrientedCursor_new () ; +extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkHyperTreeGridNonOrientedCursor * sself) ; +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(vtkHyperTreeGridNonOrientedCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local(vtkHyperTreeGridNonOrientedCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_mask(vtkHyperTreeGridNonOrientedCursor* sself, bool state); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_masked(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_root(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_cursor_get_level(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_child(vtkHyperTreeGridNonOrientedCursor* sself, unsigned char ichild); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkHyperTreeGridNonOrientedCursor* sself); +extern "C" vtkHyperTreeGridNonOrientedGeometryCursor * vtkHyperTreeGridNonOrientedGeometryCursor_new () ; +extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkHyperTreeGridNonOrientedGeometryCursor * sself) ; +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start(vtkHyperTreeGridNonOrientedGeometryCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local(vtkHyperTreeGridNonOrientedGeometryCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(vtkHyperTreeGridNonOrientedGeometryCursor* sself, bool state); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(vtkHyperTreeGridNonOrientedGeometryCursor* sself, unsigned char ichild); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkHyperTreeGridNonOrientedGeometryCursor* sself); +extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursor * vtkHyperTreeGridNonOrientedMooreSuperCursor_new () ; +extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) ; +extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursorLight * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () ; +extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) ; +extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () ; +extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) ; +extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () ; +extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) ; +extern "C" vtkHyperTreeGridOrientedCursor * vtkHyperTreeGridOrientedCursor_new () ; +extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkHyperTreeGridOrientedCursor * sself) ; +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkHyperTreeGridOrientedCursor* sself); +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkHyperTreeGridOrientedCursor* sself); +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkHyperTreeGridOrientedCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_dimension(vtkHyperTreeGridOrientedCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(vtkHyperTreeGridOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(vtkHyperTreeGridOrientedCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local(vtkHyperTreeGridOrientedCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_mask(vtkHyperTreeGridOrientedCursor* sself, bool state); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_masked(vtkHyperTreeGridOrientedCursor* sself); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_leaf(vtkHyperTreeGridOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(vtkHyperTreeGridOrientedCursor* sself); +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_root(vtkHyperTreeGridOrientedCursor* sself); +extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkHyperTreeGridOrientedCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkHyperTreeGridOrientedCursor* sself, unsigned char ichild); +extern "C" vtkHyperTreeGridOrientedGeometryCursor * vtkHyperTreeGridOrientedGeometryCursor_new () ; +extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkHyperTreeGridOrientedGeometryCursor * sself) ; +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start(vtkHyperTreeGridOrientedGeometryCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local(vtkHyperTreeGridOrientedGeometryCursor* sself, long long index); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(vtkHyperTreeGridOrientedGeometryCursor* sself, bool state); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(vtkHyperTreeGridOrientedGeometryCursor* sself); +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkHyperTreeGridOrientedGeometryCursor* sself, unsigned char ichild); +extern "C" vtkImageData * vtkImageData_new () ; +extern "C" void vtkImageData_destructor (vtkImageData * sself) ; +extern "C" int vtk_image_data_get_data_object_type(vtkImageData* sself); +extern "C" long long vtk_image_data_get_number_of_cells(vtkImageData* sself); +extern "C" long long vtk_image_data_get_number_of_points(vtkImageData* sself); +extern "C" long long vtk_image_data_find_point(vtkImageData* sself, double x, double y, double z); +extern "C" int vtk_image_data_get_cell_type(vtkImageData* sself, long long cellId); +extern "C" int vtk_image_data_get_max_cell_size(vtkImageData* sself); +extern "C" void vtk_image_data_initialize(vtkImageData* sself); +extern "C" unsigned char vtk_image_data_is_point_visible(vtkImageData* sself, long long ptId); +extern "C" unsigned char vtk_image_data_is_cell_visible(vtkImageData* sself, long long cellId); +extern "C" bool vtk_image_data_has_any_blank_points(vtkImageData* sself); +extern "C" bool vtk_image_data_has_any_blank_cells(vtkImageData* sself); +extern "C" void vtk_image_data_set_dimensions(vtkImageData* sself, int i, int j, int k); +extern "C" int vtk_image_data_get_data_dimension(vtkImageData* sself); +extern "C" void vtk_image_data_set_extent(vtkImageData* sself, int x1, int x2, int y1, int y2, int z1, int z2); +extern "C" void* vtk_image_data_get_scalar_pointer(vtkImageData* sself, int x, int y, int z); +extern "C" long long vtk_image_data_get_scalar_index(vtkImageData* sself, int x, int y, int z); +extern "C" float vtk_image_data_get_scalar_component_as_float(vtkImageData* sself, int x, int y, int z, int component); +extern "C" void vtk_image_data_set_scalar_component_from_float(vtkImageData* sself, int x, int y, int z, int component, float v); +extern "C" double vtk_image_data_get_scalar_component_as_double(vtkImageData* sself, int x, int y, int z, int component); +extern "C" void vtk_image_data_set_scalar_component_from_double(vtkImageData* sself, int x, int y, int z, int component, double v); +extern "C" void vtk_image_data_allocate_scalars(vtkImageData* sself, int dataType, int numComponents); +extern "C" void vtk_image_data_set_spacing(vtkImageData* sself, double i, double j, double k); +extern "C" void vtk_image_data_set_origin(vtkImageData* sself, double i, double j, double k); +extern "C" const char* vtk_image_data_get_scalar_type_as_string(vtkImageData* sself); +extern "C" void vtk_image_data_prepare_for_new_data(vtkImageData* sself); +extern "C" int vtk_image_data_get_extent_type(vtkImageData* sself); +extern "C" vtkImageTransform * vtkImageTransform_new () ; +extern "C" void vtkImageTransform_destructor (vtkImageTransform * sself) ; +extern "C" vtkImplicitBoolean * vtkImplicitBoolean_new () ; +extern "C" void vtkImplicitBoolean_destructor (vtkImplicitBoolean * sself) ; +extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type(vtkImplicitBoolean* sself, int _arg); +extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkImplicitBoolean* sself); +extern "C" int vtk_implicit_boolean_get_operation_type_max_value(vtkImplicitBoolean* sself); +extern "C" int vtk_implicit_boolean_get_operation_type(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_union(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_intersection(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_difference(vtkImplicitBoolean* sself); +extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(vtkImplicitBoolean* sself); +extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkImplicitBoolean* sself); +extern "C" vtkImplicitDataSet * vtkImplicitDataSet_new () ; +extern "C" void vtkImplicitDataSet_destructor (vtkImplicitDataSet * sself) ; +extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkImplicitDataSet* sself); +extern "C" void vtk_implicit_data_set_set_out_value(vtkImplicitDataSet* sself, double _arg); +extern "C" double vtk_implicit_data_set_get_out_value(vtkImplicitDataSet* sself); +extern "C" void vtk_implicit_data_set_set_out_gradient(vtkImplicitDataSet* sself, double _arg1, double _arg2, double _arg3); +extern "C" vtkImplicitFunctionCollection * vtkImplicitFunctionCollection_new () ; +extern "C" void vtkImplicitFunctionCollection_destructor (vtkImplicitFunctionCollection * sself) ; +extern "C" vtkImplicitHalo * vtkImplicitHalo_new () ; +extern "C" void vtkImplicitHalo_destructor (vtkImplicitHalo * sself) ; +extern "C" void vtk_implicit_halo_set_radius(vtkImplicitHalo* sself, double _arg); +extern "C" double vtk_implicit_halo_get_radius(vtkImplicitHalo* sself); +extern "C" void vtk_implicit_halo_set_center(vtkImplicitHalo* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_implicit_halo_set_fade_out(vtkImplicitHalo* sself, double _arg); +extern "C" double vtk_implicit_halo_get_fade_out(vtkImplicitHalo* sself); +extern "C" vtkImplicitSelectionLoop * vtkImplicitSelectionLoop_new () ; +extern "C" void vtkImplicitSelectionLoop_destructor (vtkImplicitSelectionLoop * sself) ; +extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkImplicitSelectionLoop* sself, int _arg); +extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkImplicitSelectionLoop* sself); +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkImplicitSelectionLoop* sself); +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_off(vtkImplicitSelectionLoop* sself); +extern "C" void vtk_implicit_selection_loop_set_normal(vtkImplicitSelectionLoop* sself, double _arg1, double _arg2, double _arg3); +extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkImplicitSelectionLoop* sself); +extern "C" vtkImplicitSum * vtkImplicitSum_new () ; +extern "C" void vtkImplicitSum_destructor (vtkImplicitSum * sself) ; +extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkImplicitSum* sself); +extern "C" void vtk_implicit_sum_remove_all_functions(vtkImplicitSum* sself); +extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkImplicitSum* sself, int _arg); +extern "C" int vtk_implicit_sum_get_normalize_by_weight(vtkImplicitSum* sself); +extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkImplicitSum* sself); +extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkImplicitSum* sself); +extern "C" vtkImplicitVolume * vtkImplicitVolume_new () ; +extern "C" void vtkImplicitVolume_destructor (vtkImplicitVolume * sself) ; +extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkImplicitVolume* sself); +extern "C" void vtk_implicit_volume_set_out_value(vtkImplicitVolume* sself, double _arg); +extern "C" double vtk_implicit_volume_get_out_value(vtkImplicitVolume* sself); +extern "C" void vtk_implicit_volume_set_out_gradient(vtkImplicitVolume* sself, double _arg1, double _arg2, double _arg3); +extern "C" vtkImplicitWindowFunction * vtkImplicitWindowFunction_new () ; +extern "C" void vtkImplicitWindowFunction_destructor (vtkImplicitWindowFunction * sself) ; +extern "C" void vtk_implicit_window_function_set_window_range(vtkImplicitWindowFunction* sself, double _arg1, double _arg2); +extern "C" void vtk_implicit_window_function_set_window_values(vtkImplicitWindowFunction* sself, double _arg1, double _arg2); +extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkImplicitWindowFunction* sself); +extern "C" vtkInEdgeIterator * vtkInEdgeIterator_new () ; +extern "C" void vtkInEdgeIterator_destructor (vtkInEdgeIterator * sself) ; +extern "C" long long vtk_in_edge_iterator_get_vertex(vtkInEdgeIterator* sself); +extern "C" bool vtk_in_edge_iterator_has_next(vtkInEdgeIterator* sself); +extern "C" vtkIncrementalOctreeNode * vtkIncrementalOctreeNode_new () ; +extern "C" void vtkIncrementalOctreeNode_destructor (vtkIncrementalOctreeNode * sself) ; +extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkIncrementalOctreeNode* sself); +extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkIncrementalOctreeNode* sself); +extern "C" void vtk_incremental_octree_node_set_bounds(vtkIncrementalOctreeNode* sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" int vtk_incremental_octree_node_is_leaf(vtkIncrementalOctreeNode* sself); +extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkIncrementalOctreeNode* sself); +extern "C" int vtk_incremental_octree_node_get_id(vtkIncrementalOctreeNode* sself); +extern "C" vtkIncrementalOctreePointLocator * vtkIncrementalOctreePointLocator_new () ; +extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkIncrementalOctreePointLocator * sself) ; +extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself, int _arg); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkIncrementalOctreePointLocator* sself); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkIncrementalOctreePointLocator* sself); +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_set_build_cubic_octree(vtkIncrementalOctreePointLocator* sself, int _arg); +extern "C" int vtk_incremental_octree_point_locator_get_build_cubic_octree(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_on(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_off(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_initialize(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_free_search_structure(vtkIncrementalOctreePointLocator* sself); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_points(vtkIncrementalOctreePointLocator* sself); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_nodes(vtkIncrementalOctreePointLocator* sself); +extern "C" void vtk_incremental_octree_point_locator_build_locator(vtkIncrementalOctreePointLocator* sself); +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkIncrementalOctreePointLocator* sself, double x, double y, double z); +extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkIncrementalOctreePointLocator* sself, double x, double y, double z); +extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkIncrementalOctreePointLocator* sself); +extern "C" vtkIterativeClosestPointTransform * vtkIterativeClosestPointTransform_new () ; +extern "C" void vtkIterativeClosestPointTransform_destructor (vtkIterativeClosestPointTransform * sself) ; +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself); +extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_check_mean_distance(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_check_mean_distance(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_on(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_off(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value(vtkIterativeClosestPointTransform* sself); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value(vtkIterativeClosestPointTransform* sself); +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value(vtkIterativeClosestPointTransform* sself); +extern "C" const char* vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_maximum_mean_distance(vtkIterativeClosestPointTransform* sself, double _arg); +extern "C" double vtk_iterative_closest_point_transform_get_maximum_mean_distance(vtkIterativeClosestPointTransform* sself); +extern "C" double vtk_iterative_closest_point_transform_get_mean_distance(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_set_start_by_matching_centroids(vtkIterativeClosestPointTransform* sself, int _arg); +extern "C" int vtk_iterative_closest_point_transform_get_start_by_matching_centroids(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_on(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_off(vtkIterativeClosestPointTransform* sself); +extern "C" void vtk_iterative_closest_point_transform_inverse(vtkIterativeClosestPointTransform* sself); +extern "C" vtkKdNode * vtkKdNode_new () ; +extern "C" void vtkKdNode_destructor (vtkKdNode * sself) ; +extern "C" void vtk_kd_node_set_dim(vtkKdNode* sself, int _arg); +extern "C" int vtk_kd_node_get_dim(vtkKdNode* sself); +extern "C" double vtk_kd_node_get_division_position(vtkKdNode* sself); +extern "C" void vtk_kd_node_set_number_of_points(vtkKdNode* sself, int _arg); +extern "C" int vtk_kd_node_get_number_of_points(vtkKdNode* sself); +extern "C" void vtk_kd_node_set_bounds(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" void vtk_kd_node_set_data_bounds(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2); +extern "C" void vtk_kd_node_set_id(vtkKdNode* sself, int _arg); +extern "C" int vtk_kd_node_get_id(vtkKdNode* sself); +extern "C" int vtk_kd_node_get_min_id(vtkKdNode* sself); +extern "C" int vtk_kd_node_get_max_id(vtkKdNode* sself); +extern "C" void vtk_kd_node_set_min_id(vtkKdNode* sself, int _arg); +extern "C" void vtk_kd_node_set_max_id(vtkKdNode* sself, int _arg); +extern "C" void vtk_kd_node_delete_child_nodes(vtkKdNode* sself); +extern "C" int vtk_kd_node_intersects_box(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds); +extern "C" int vtk_kd_node_intersects_sphere_2(vtkKdNode* sself, double x, double y, double z, double rSquared, int useDataBounds); +extern "C" int vtk_kd_node_contains_box(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds); +extern "C" int vtk_kd_node_contains_point(vtkKdNode* sself, double x, double y, double z, int useDataBounds); +extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkKdNode* sself, double x, double y, double z, int useDataBounds); +extern "C" double vtk_kd_node_get_distance_2_to_inner_boundary(vtkKdNode* sself, double x, double y, double z); +extern "C" void vtk_kd_node_print_node(vtkKdNode* sself, int depth); +extern "C" void vtk_kd_node_print_verbose_node(vtkKdNode* sself, int depth); +extern "C" vtkKdTree * vtkKdTree_new () ; +extern "C" void vtkKdTree_destructor (vtkKdTree * sself) ; +extern "C" void vtk_kd_tree_timing_on(vtkKdTree* sself); +extern "C" void vtk_kd_tree_timing_off(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_timing(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_timing(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_min_cells(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_min_cells(vtkKdTree* sself); +extern "C" int vtk_kd_tree_get_number_of_regions_or_less(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_number_of_regions_or_less(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_number_of_regions_or_more(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_number_of_regions_or_more(vtkKdTree* sself, int _arg); +extern "C" double vtk_kd_tree_get_fudge_factor(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_fudge_factor(vtkKdTree* sself, double _arg); +extern "C" void vtk_kd_tree_omit_x_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_y_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_z_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_xy_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_yz_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_zx_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_omit_no_partitioning(vtkKdTree* sself); +extern "C" void vtk_kd_tree_remove_data_set(vtkKdTree* sself, int index); +extern "C" void vtk_kd_tree_remove_all_data_sets(vtkKdTree* sself); +extern "C" int vtk_kd_tree_get_number_of_data_sets(vtkKdTree* sself); +extern "C" int vtk_kd_tree_get_number_of_regions(vtkKdTree* sself); +extern "C" void vtk_kd_tree_print_tree(vtkKdTree* sself); +extern "C" void vtk_kd_tree_print_verbose_tree(vtkKdTree* sself); +extern "C" void vtk_kd_tree_print_region(vtkKdTree* sself, int id); +extern "C" void vtk_kd_tree_set_include_region_boundary_cells(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_include_region_boundary_cells(vtkKdTree* sself); +extern "C" void vtk_kd_tree_include_region_boundary_cells_on(vtkKdTree* sself); +extern "C" void vtk_kd_tree_include_region_boundary_cells_off(vtkKdTree* sself); +extern "C" void vtk_kd_tree_delete_cell_lists(vtkKdTree* sself); +extern "C" int vtk_kd_tree_get_region_containing_point(vtkKdTree* sself, double x, double y, double z); +extern "C" void vtk_kd_tree_build_locator(vtkKdTree* sself); +extern "C" void vtk_kd_tree_free_search_structure(vtkKdTree* sself); +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_on(vtkKdTree* sself); +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_off(vtkKdTree* sself); +extern "C" void vtk_kd_tree_set_generate_representation_using_data_bounds(vtkKdTree* sself, int _arg); +extern "C" int vtk_kd_tree_get_generate_representation_using_data_bounds(vtkKdTree* sself); +extern "C" int vtk_kd_tree_new_geometry(vtkKdTree* sself); +extern "C" void vtk_kd_tree_invalidate_geometry(vtkKdTree* sself); +extern "C" vtkKdTreePointLocator * vtkKdTreePointLocator_new () ; +extern "C" void vtkKdTreePointLocator_destructor (vtkKdTreePointLocator * sself) ; +extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkKdTreePointLocator* sself); +extern "C" void vtk_kd_tree_point_locator_build_locator(vtkKdTreePointLocator* sself); +extern "C" vtkLagrangeCurve * vtkLagrangeCurve_new () ; +extern "C" void vtkLagrangeCurve_destructor (vtkLagrangeCurve * sself) ; +extern "C" int vtk_lagrange_curve_get_cell_type(vtkLagrangeCurve* sself); +extern "C" vtkLagrangeHexahedron * vtkLagrangeHexahedron_new () ; +extern "C" void vtkLagrangeHexahedron_destructor (vtkLagrangeHexahedron * sself) ; +extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkLagrangeHexahedron* sself); +extern "C" vtkLagrangeInterpolation * vtkLagrangeInterpolation_new () ; +extern "C" void vtkLagrangeInterpolation_destructor (vtkLagrangeInterpolation * sself) ; +extern "C" vtkLagrangeQuadrilateral * vtkLagrangeQuadrilateral_new () ; +extern "C" void vtkLagrangeQuadrilateral_destructor (vtkLagrangeQuadrilateral * sself) ; +extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkLagrangeQuadrilateral* sself); +extern "C" vtkLagrangeTetra * vtkLagrangeTetra_new () ; +extern "C" void vtkLagrangeTetra_destructor (vtkLagrangeTetra * sself) ; +extern "C" int vtk_lagrange_tetra_get_cell_type(vtkLagrangeTetra* sself); +extern "C" vtkLagrangeTriangle * vtkLagrangeTriangle_new () ; +extern "C" void vtkLagrangeTriangle_destructor (vtkLagrangeTriangle * sself) ; +extern "C" int vtk_lagrange_triangle_get_cell_type(vtkLagrangeTriangle* sself); +extern "C" vtkLagrangeWedge * vtkLagrangeWedge_new () ; +extern "C" void vtkLagrangeWedge_destructor (vtkLagrangeWedge * sself) ; +extern "C" int vtk_lagrange_wedge_get_cell_type(vtkLagrangeWedge* sself); +extern "C" vtkLine * vtkLine_new () ; +extern "C" void vtkLine_destructor (vtkLine * sself) ; +extern "C" int vtk_line_get_cell_type(vtkLine* sself); +extern "C" int vtk_line_get_cell_dimension(vtkLine* sself); +extern "C" int vtk_line_get_number_of_edges(vtkLine* sself); +extern "C" int vtk_line_get_number_of_faces(vtkLine* sself); +extern "C" int vtk_line_inflate(vtkLine* sself, double dist); +extern "C" vtkMeanValueCoordinatesInterpolator * vtkMeanValueCoordinatesInterpolator_new () ; +extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkMeanValueCoordinatesInterpolator * sself) ; +extern "C" vtkMergePoints * vtkMergePoints_new () ; +extern "C" void vtkMergePoints_destructor (vtkMergePoints * sself) ; +extern "C" vtkMolecule * vtkMolecule_new () ; +extern "C" void vtkMolecule_destructor (vtkMolecule * sself) ; +extern "C" long long vtk_molecule_get_number_of_atoms(vtkMolecule* sself); +extern "C" long long vtk_molecule_get_number_of_bonds(vtkMolecule* sself); +extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkMolecule* sself, long long atomId); +extern "C" void vtk_molecule_set_atom_atomic_number(vtkMolecule* sself, long long atomId, unsigned short atomicNum); +extern "C" void vtk_molecule_set_bond_order(vtkMolecule* sself, long long bondId, unsigned short order); +extern "C" unsigned short vtk_molecule_get_bond_order(vtkMolecule* sself, long long bondId); +extern "C" double vtk_molecule_get_bond_length(vtkMolecule* sself, long long bondId); +extern "C" bool vtk_molecule_has_lattice(vtkMolecule* sself); +extern "C" void vtk_molecule_clear_lattice(vtkMolecule* sself); +extern "C" void vtk_molecule_allocate_atom_ghost_array(vtkMolecule* sself); +extern "C" void vtk_molecule_allocate_bond_ghost_array(vtkMolecule* sself); +extern "C" long long vtk_molecule_get_bond_id(vtkMolecule* sself, long long a, long long b); +extern "C" void vtk_molecule_set_atomic_number_array_name(vtkMolecule* sself, const char* _arg); +extern "C" void vtk_molecule_set_bond_orders_array_name(vtkMolecule* sself, const char* _arg); +extern "C" vtkMultiBlockDataSet * vtkMultiBlockDataSet_new () ; +extern "C" void vtkMultiBlockDataSet_destructor (vtkMultiBlockDataSet * sself) ; +extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkMultiBlockDataSet* sself, unsigned int numBlocks); +extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkMultiBlockDataSet* sself); +extern "C" void vtk_multi_block_data_set_remove_block(vtkMultiBlockDataSet* sself, unsigned int blockno); +extern "C" int vtk_multi_block_data_set_has_meta_data(vtkMultiBlockDataSet* sself, unsigned int blockno); +extern "C" vtkMultiPieceDataSet * vtkMultiPieceDataSet_new () ; +extern "C" void vtkMultiPieceDataSet_destructor (vtkMultiPieceDataSet * sself) ; +extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkMultiPieceDataSet* sself, unsigned int numpieces); +extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkMultiPieceDataSet* sself); +extern "C" vtkMutableDirectedGraph * vtkMutableDirectedGraph_new () ; +extern "C" void vtkMutableDirectedGraph_destructor (vtkMutableDirectedGraph * sself) ; +extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkMutableDirectedGraph* sself, long long numVerts); +extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkMutableDirectedGraph* sself); +extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkMutableDirectedGraph* sself); +extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkMutableDirectedGraph* sself, long long v); +extern "C" void vtk_mutable_directed_graph_remove_edge(vtkMutableDirectedGraph* sself, long long e); +extern "C" vtkMutableUndirectedGraph * vtkMutableUndirectedGraph_new () ; +extern "C" void vtkMutableUndirectedGraph_destructor (vtkMutableUndirectedGraph * sself) ; +extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkMutableUndirectedGraph* sself, long long numVerts); +extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkMutableUndirectedGraph* sself); +extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkMutableUndirectedGraph* sself); +extern "C" void vtk_mutable_undirected_graph_lazy_add_edge(vtkMutableUndirectedGraph* sself, long long u, long long v); +extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkMutableUndirectedGraph* sself, long long v); +extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkMutableUndirectedGraph* sself, long long e); +extern "C" vtkNonMergingPointLocator * vtkNonMergingPointLocator_new () ; +extern "C" void vtkNonMergingPointLocator_destructor (vtkNonMergingPointLocator * sself) ; +extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNonMergingPointLocator* sself, double p0, double p1, double p2); +extern "C" vtkNonOverlappingAMR * vtkNonOverlappingAMR_new () ; +extern "C" void vtkNonOverlappingAMR_destructor (vtkNonOverlappingAMR * sself) ; +extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNonOverlappingAMR* sself); +extern "C" vtkOctreePointLocator * vtkOctreePointLocator_new () ; +extern "C" void vtkOctreePointLocator_destructor (vtkOctreePointLocator * sself) ; +extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkOctreePointLocator* sself, int _arg); +extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkOctreePointLocator* sself); +extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkOctreePointLocator* sself, int _arg); +extern "C" int vtk_octree_point_locator_get_create_cubic_octants(vtkOctreePointLocator* sself); +extern "C" double vtk_octree_point_locator_get_fudge_factor(vtkOctreePointLocator* sself); +extern "C" void vtk_octree_point_locator_set_fudge_factor(vtkOctreePointLocator* sself, double _arg); +extern "C" int vtk_octree_point_locator_get_number_of_leaf_nodes(vtkOctreePointLocator* sself); +extern "C" int vtk_octree_point_locator_get_region_containing_point(vtkOctreePointLocator* sself, double x, double y, double z); +extern "C" void vtk_octree_point_locator_build_locator(vtkOctreePointLocator* sself); +extern "C" long long vtk_octree_point_locator_find_closest_point(vtkOctreePointLocator* sself, double x, double y, double z, double& dist2); +extern "C" void vtk_octree_point_locator_free_search_structure(vtkOctreePointLocator* sself); +extern "C" vtkOctreePointLocatorNode * vtkOctreePointLocatorNode_new () ; +extern "C" void vtkOctreePointLocatorNode_destructor (vtkOctreePointLocatorNode * sself) ; +extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkOctreePointLocatorNode* sself, int numberOfPoints); +extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkOctreePointLocatorNode* sself); +extern "C" void vtk_octree_point_locator_node_set_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_octree_point_locator_node_set_data_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" int vtk_octree_point_locator_node_get_id(vtkOctreePointLocatorNode* sself); +extern "C" int vtk_octree_point_locator_node_get_min_id(vtkOctreePointLocatorNode* sself); +extern "C" void vtk_octree_point_locator_node_create_child_nodes(vtkOctreePointLocatorNode* sself); +extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkOctreePointLocatorNode* sself); +extern "C" int vtk_octree_point_locator_node_contains_point(vtkOctreePointLocatorNode* sself, double x, double y, double z, int useDataBounds); +extern "C" vtkOrderedTriangulator * vtkOrderedTriangulator_new () ; +extern "C" void vtkOrderedTriangulator_destructor (vtkOrderedTriangulator * sself) ; +extern "C" void vtk_ordered_triangulator_init_triangulation(vtkOrderedTriangulator* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts); +extern "C" void vtk_ordered_triangulator_triangulate(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_template_triangulate(vtkOrderedTriangulator* sself, int cellType, int numPts, int numEdges); +extern "C" void vtk_ordered_triangulator_update_point_type(vtkOrderedTriangulator* sself, long long internalId, int type); +extern "C" long long vtk_ordered_triangulator_get_point_id(vtkOrderedTriangulator* sself, long long internalId); +extern "C" int vtk_ordered_triangulator_get_number_of_points(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_set_use_templates(vtkOrderedTriangulator* sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_use_templates(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_use_templates_on(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_use_templates_off(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_set_pre_sorted(vtkOrderedTriangulator* sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_pre_sorted(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_pre_sorted_on(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_pre_sorted_off(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_set_use_two_sort_ids(vtkOrderedTriangulator* sself, int _arg); +extern "C" int vtk_ordered_triangulator_get_use_two_sort_ids(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_on(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkOrderedTriangulator* sself); +extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkOrderedTriangulator* sself); +extern "C" vtkOutEdgeIterator * vtkOutEdgeIterator_new () ; +extern "C" void vtkOutEdgeIterator_destructor (vtkOutEdgeIterator * sself) ; +extern "C" long long vtk_out_edge_iterator_get_vertex(vtkOutEdgeIterator* sself); +extern "C" bool vtk_out_edge_iterator_has_next(vtkOutEdgeIterator* sself); +extern "C" vtkOverlappingAMR * vtkOverlappingAMR_new () ; +extern "C" void vtkOverlappingAMR_destructor (vtkOverlappingAMR * sself) ; +extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level, int refRatio); +extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level); +extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id, int sourceId); +extern "C" int vtk_overlapping_amr_get_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id); +extern "C" bool vtk_overlapping_amr_has_children_information(vtkOverlappingAMR* sself); +extern "C" void vtk_overlapping_amr_generate_parent_child_information(vtkOverlappingAMR* sself); +extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkOverlappingAMR* sself, unsigned int level, unsigned int index); +extern "C" void vtk_overlapping_amr_audit(vtkOverlappingAMR* sself); +extern "C" vtkPartitionedDataSet * vtkPartitionedDataSet_new () ; +extern "C" void vtkPartitionedDataSet_destructor (vtkPartitionedDataSet * sself) ; +extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkPartitionedDataSet* sself, unsigned int numPartitions); +extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkPartitionedDataSet* sself); +extern "C" int vtk_partitioned_data_set_has_meta_data(vtkPartitionedDataSet* sself, unsigned int idx); +extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkPartitionedDataSet* sself); +extern "C" vtkPartitionedDataSetCollection * vtkPartitionedDataSetCollection_new () ; +extern "C" void vtkPartitionedDataSetCollection_destructor (vtkPartitionedDataSetCollection * sself) ; +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself, unsigned int numDataSets); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself); +extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkPartitionedDataSetCollection* sself, unsigned int idx); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitions(vtkPartitionedDataSetCollection* sself, unsigned int idx); +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitions(vtkPartitionedDataSetCollection* sself, unsigned int idx, unsigned int numPartitions); +extern "C" int vtk_partitioned_data_set_collection_has_meta_data(vtkPartitionedDataSetCollection* sself, unsigned int idx); +extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkPartitionedDataSetCollection* sself, unsigned int idx); +extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkPartitionedDataSetCollection* sself); +extern "C" vtkPath * vtkPath_new () ; +extern "C" void vtkPath_destructor (vtkPath * sself) ; +extern "C" int vtk_path_get_data_object_type(vtkPath* sself); +extern "C" void vtk_path_insert_next_point(vtkPath* sself, double x, double y, double z, int code); +extern "C" long long vtk_path_get_number_of_cells(vtkPath* sself); +extern "C" int vtk_path_get_max_cell_size(vtkPath* sself); +extern "C" void vtk_path_allocate(vtkPath* sself, long long size, int extSize); +extern "C" void vtk_path_reset(vtkPath* sself); +extern "C" vtkPentagonalPrism * vtkPentagonalPrism_new () ; +extern "C" void vtkPentagonalPrism_destructor (vtkPentagonalPrism * sself) ; +extern "C" int vtk_pentagonal_prism_get_cell_type(vtkPentagonalPrism* sself); +extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkPentagonalPrism* sself); +extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkPentagonalPrism* sself); +extern "C" vtkPerlinNoise * vtkPerlinNoise_new () ; +extern "C" void vtkPerlinNoise_destructor (vtkPerlinNoise * sself) ; +extern "C" void vtk_perlin_noise_set_frequency(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_perlin_noise_set_phase(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_perlin_noise_set_amplitude(vtkPerlinNoise* sself, double _arg); +extern "C" double vtk_perlin_noise_get_amplitude(vtkPerlinNoise* sself); +extern "C" vtkPiecewiseFunction * vtkPiecewiseFunction_new () ; +extern "C" void vtkPiecewiseFunction_destructor (vtkPiecewiseFunction * sself) ; +extern "C" int vtk_piecewise_function_get_data_object_type(vtkPiecewiseFunction* sself); +extern "C" int vtk_piecewise_function_get_size(vtkPiecewiseFunction* sself); +extern "C" int vtk_piecewise_function_add_point(vtkPiecewiseFunction* sself, double x, double y); +extern "C" bool vtk_piecewise_function_remove_point_by_index(vtkPiecewiseFunction* sself, size_t id); +extern "C" int vtk_piecewise_function_remove_point(vtkPiecewiseFunction* sself, double x); +extern "C" void vtk_piecewise_function_remove_all_points(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_add_segment(vtkPiecewiseFunction* sself, double x1, double y1, double x2, double y2); +extern "C" double vtk_piecewise_function_get_value(vtkPiecewiseFunction* sself, double x); +extern "C" void vtk_piecewise_function_set_clamping(vtkPiecewiseFunction* sself, int _arg); +extern "C" int vtk_piecewise_function_get_clamping(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_clamping_on(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_clamping_off(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_set_use_log_scale(vtkPiecewiseFunction* sself, bool _arg); +extern "C" bool vtk_piecewise_function_get_use_log_scale(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_use_log_scale_on(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_use_log_scale_off(vtkPiecewiseFunction* sself); +extern "C" const char* vtk_piecewise_function_get_type(vtkPiecewiseFunction* sself); +extern "C" double vtk_piecewise_function_get_first_non_zero_value(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_initialize(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_set_allow_duplicate_scalars(vtkPiecewiseFunction* sself, int _arg); +extern "C" int vtk_piecewise_function_get_allow_duplicate_scalars(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_on(vtkPiecewiseFunction* sself); +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkPiecewiseFunction* sself); +extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkPiecewiseFunction* sself, const double& x1, const double& x2); +extern "C" vtkPixel * vtkPixel_new () ; +extern "C" void vtkPixel_destructor (vtkPixel * sself) ; +extern "C" int vtk_pixel_get_cell_type(vtkPixel* sself); +extern "C" int vtk_pixel_get_cell_dimension(vtkPixel* sself); +extern "C" int vtk_pixel_get_number_of_edges(vtkPixel* sself); +extern "C" int vtk_pixel_get_number_of_faces(vtkPixel* sself); +extern "C" int vtk_pixel_inflate(vtkPixel* sself, double dist); +extern "C" vtkPlane * vtkPlane_new () ; +extern "C" void vtkPlane_destructor (vtkPlane * sself) ; +extern "C" void vtk_plane_set_normal(vtkPlane* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_plane_set_origin(vtkPlane* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_plane_push(vtkPlane* sself, double distance); +extern "C" vtkPlaneCollection * vtkPlaneCollection_new () ; +extern "C" void vtkPlaneCollection_destructor (vtkPlaneCollection * sself) ; +extern "C" int vtk_plane_collection_get_number_of_items(vtkPlaneCollection* sself); +extern "C" vtkPlanes * vtkPlanes_new () ; +extern "C" void vtkPlanes_destructor (vtkPlanes * sself) ; +extern "C" void vtk_planes_set_bounds(vtkPlanes* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax); +extern "C" int vtk_planes_get_number_of_planes(vtkPlanes* sself); +extern "C" vtkPlanesIntersection * vtkPlanesIntersection_new () ; +extern "C" void vtkPlanesIntersection_destructor (vtkPlanesIntersection * sself) ; +extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkPlanesIntersection* sself); +extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkPlanesIntersection* sself); +extern "C" vtkPointData * vtkPointData_new () ; +extern "C" void vtkPointData_destructor (vtkPointData * sself) ; +extern "C" void vtk_point_data_null_point(vtkPointData* sself, long long ptId); +extern "C" vtkPointLocator * vtkPointLocator_new () ; +extern "C" void vtkPointLocator_destructor (vtkPointLocator * sself) ; +extern "C" void vtk_point_locator_set_divisions(vtkPointLocator* sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkPointLocator* sself, int _arg); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkPointLocator* sself); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_max_value(vtkPointLocator* sself); +extern "C" int vtk_point_locator_get_number_of_points_per_bucket(vtkPointLocator* sself); +extern "C" long long vtk_point_locator_is_inserted_point(vtkPointLocator* sself, double x, double y, double z); +extern "C" void vtk_point_locator_initialize(vtkPointLocator* sself); +extern "C" void vtk_point_locator_free_search_structure(vtkPointLocator* sself); +extern "C" void vtk_point_locator_build_locator(vtkPointLocator* sself); +extern "C" vtkPointSet * vtkPointSet_new () ; +extern "C" void vtkPointSet_destructor (vtkPointSet * sself) ; +extern "C" void vtk_point_set_set_editable(vtkPointSet* sself, bool _arg); +extern "C" bool vtk_point_set_get_editable(vtkPointSet* sself); +extern "C" void vtk_point_set_editable_on(vtkPointSet* sself); +extern "C" void vtk_point_set_editable_off(vtkPointSet* sself); +extern "C" void vtk_point_set_initialize(vtkPointSet* sself); +extern "C" long long vtk_point_set_get_number_of_points(vtkPointSet* sself); +extern "C" long long vtk_point_set_get_number_of_cells(vtkPointSet* sself); +extern "C" int vtk_point_set_get_max_cell_size(vtkPointSet* sself); +extern "C" int vtk_point_set_get_cell_type(vtkPointSet* sself, long long p0); +extern "C" void vtk_point_set_build_point_locator(vtkPointSet* sself); +extern "C" void vtk_point_set_build_locator(vtkPointSet* sself); +extern "C" void vtk_point_set_build_cell_locator(vtkPointSet* sself); +extern "C" unsigned long vtk_point_set_get_m_time(vtkPointSet* sself); +extern "C" void vtk_point_set_compute_bounds(vtkPointSet* sself); +extern "C" void vtk_point_set_squeeze(vtkPointSet* sself); +extern "C" vtkPointSetCellIterator * vtkPointSetCellIterator_new () ; +extern "C" void vtkPointSetCellIterator_destructor (vtkPointSetCellIterator * sself) ; +extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkPointSetCellIterator* sself); +extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkPointSetCellIterator* sself); +extern "C" vtkPointsProjectedHull * vtkPointsProjectedHull_new () ; +extern "C" void vtkPointsProjectedHull_destructor (vtkPointsProjectedHull * sself) ; +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkPointsProjectedHull* sself); +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkPointsProjectedHull* sself); +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkPointsProjectedHull* sself); +extern "C" void vtk_points_projected_hull_update(vtkPointsProjectedHull* sself); +extern "C" vtkPolyData * vtkPolyData_new () ; +extern "C" void vtkPolyData_destructor (vtkPolyData * sself) ; +extern "C" int vtk_poly_data_get_data_object_type(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_number_of_cells(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_cell_type(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_compute_cells_bounds(vtkPolyData* sself); +extern "C" void vtk_poly_data_squeeze(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_max_cell_size(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_cell_id_relative_to_cell_array(vtkPolyData* sself, long long cellId); +extern "C" long long vtk_poly_data_get_number_of_verts(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_number_of_lines(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_number_of_polys(vtkPolyData* sself); +extern "C" long long vtk_poly_data_get_number_of_strips(vtkPolyData* sself); +extern "C" bool vtk_poly_data_allocate_estimate(vtkPolyData* sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_poly_data_allocate_exact(vtkPolyData* sself, long long numCells, long long connectivitySize); +extern "C" void vtk_poly_data_allocate(vtkPolyData* sself, long long numCells, int extSize); +extern "C" void vtk_poly_data_reset(vtkPolyData* sself); +extern "C" void vtk_poly_data_build_cells(vtkPolyData* sself); +extern "C" bool vtk_poly_data_need_to_build_cells(vtkPolyData* sself); +extern "C" void vtk_poly_data_build_links(vtkPolyData* sself, int initialSize); +extern "C" void vtk_poly_data_delete_cells(vtkPolyData* sself); +extern "C" void vtk_poly_data_delete_links(vtkPolyData* sself); +extern "C" int vtk_poly_data_is_triangle(vtkPolyData* sself, int v1, int v2, int v3); +extern "C" int vtk_poly_data_is_edge(vtkPolyData* sself, long long p1, long long p2); +extern "C" int vtk_poly_data_is_point_used_by_cell(vtkPolyData* sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_replace_cell_point(vtkPolyData* sself, long long cellId, long long oldPtId, long long newPtId); +extern "C" void vtk_poly_data_reverse_cell(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_delete_point(vtkPolyData* sself, long long ptId); +extern "C" void vtk_poly_data_delete_cell(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_remove_deleted_cells(vtkPolyData* sself); +extern "C" long long vtk_poly_data_insert_next_linked_point(vtkPolyData* sself, int numLinks); +extern "C" void vtk_poly_data_remove_cell_reference(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_add_cell_reference(vtkPolyData* sself, long long cellId); +extern "C" void vtk_poly_data_remove_reference_to_cell(vtkPolyData* sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_add_reference_to_cell(vtkPolyData* sself, long long ptId, long long cellId); +extern "C" void vtk_poly_data_resize_cell_list(vtkPolyData* sself, long long ptId, int size); +extern "C" void vtk_poly_data_initialize(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_piece(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_number_of_pieces(vtkPolyData* sself); +extern "C" int vtk_poly_data_get_ghost_level(vtkPolyData* sself); +extern "C" void vtk_poly_data_remove_ghost_cells(vtkPolyData* sself); +extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkPolyData* sself); +extern "C" unsigned long vtk_poly_data_get_m_time(vtkPolyData* sself); +extern "C" vtkPolyDataCollection * vtkPolyDataCollection_new () ; +extern "C" void vtkPolyDataCollection_destructor (vtkPolyDataCollection * sself) ; +extern "C" vtkPolyLine * vtkPolyLine_new () ; +extern "C" void vtkPolyLine_destructor (vtkPolyLine * sself) ; +extern "C" int vtk_poly_line_get_cell_type(vtkPolyLine* sself); +extern "C" int vtk_poly_line_get_cell_dimension(vtkPolyLine* sself); +extern "C" int vtk_poly_line_get_number_of_edges(vtkPolyLine* sself); +extern "C" int vtk_poly_line_get_number_of_faces(vtkPolyLine* sself); +extern "C" vtkPolyPlane * vtkPolyPlane_new () ; +extern "C" void vtkPolyPlane_destructor (vtkPolyPlane * sself) ; +extern "C" unsigned long vtk_poly_plane_get_m_time(vtkPolyPlane* sself); +extern "C" vtkPolyVertex * vtkPolyVertex_new () ; +extern "C" void vtkPolyVertex_destructor (vtkPolyVertex * sself) ; +extern "C" int vtk_poly_vertex_get_cell_type(vtkPolyVertex* sself); +extern "C" int vtk_poly_vertex_get_cell_dimension(vtkPolyVertex* sself); +extern "C" int vtk_poly_vertex_get_number_of_edges(vtkPolyVertex* sself); +extern "C" int vtk_poly_vertex_get_number_of_faces(vtkPolyVertex* sself); +extern "C" vtkPolygon * vtkPolygon_new () ; +extern "C" void vtkPolygon_destructor (vtkPolygon * sself) ; +extern "C" int vtk_polygon_get_cell_type(vtkPolygon* sself); +extern "C" int vtk_polygon_get_cell_dimension(vtkPolygon* sself); +extern "C" int vtk_polygon_get_number_of_edges(vtkPolygon* sself); +extern "C" int vtk_polygon_get_number_of_faces(vtkPolygon* sself); +extern "C" double vtk_polygon_compute_area(vtkPolygon* sself); +extern "C" bool vtk_polygon_is_convex(vtkPolygon* sself); +extern "C" bool vtk_polygon_get_use_mvc_interpolation(vtkPolygon* sself); +extern "C" void vtk_polygon_set_use_mvc_interpolation(vtkPolygon* sself, bool _arg); +extern "C" void vtk_polygon_set_tolerance(vtkPolygon* sself, double _arg); +extern "C" double vtk_polygon_get_tolerance_min_value(vtkPolygon* sself); +extern "C" double vtk_polygon_get_tolerance_max_value(vtkPolygon* sself); +extern "C" double vtk_polygon_get_tolerance(vtkPolygon* sself); +extern "C" int vtk_polygon_ear_cut_triangulation(vtkPolygon* sself, int measure); +extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkPolygon* sself, int seed, int measure); +extern "C" vtkPolyhedron * vtkPolyhedron_new () ; +extern "C" void vtkPolyhedron_destructor (vtkPolyhedron * sself) ; +extern "C" int vtk_polyhedron_get_cell_type(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_requires_initialization(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_get_number_of_edges(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_get_number_of_faces(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_is_primary_cell(vtkPolyhedron* sself); +extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkPolyhedron* sself); +extern "C" bool vtk_polyhedron_is_convex(vtkPolyhedron* sself); +extern "C" vtkPyramid * vtkPyramid_new () ; +extern "C" void vtkPyramid_destructor (vtkPyramid * sself) ; +extern "C" int vtk_pyramid_get_cell_type(vtkPyramid* sself); +extern "C" int vtk_pyramid_get_number_of_edges(vtkPyramid* sself); +extern "C" int vtk_pyramid_get_number_of_faces(vtkPyramid* sself); +extern "C" vtkQuad * vtkQuad_new () ; +extern "C" void vtkQuad_destructor (vtkQuad * sself) ; +extern "C" int vtk_quad_get_cell_type(vtkQuad* sself); +extern "C" int vtk_quad_get_cell_dimension(vtkQuad* sself); +extern "C" int vtk_quad_get_number_of_edges(vtkQuad* sself); +extern "C" int vtk_quad_get_number_of_faces(vtkQuad* sself); +extern "C" vtkQuadraticEdge * vtkQuadraticEdge_new () ; +extern "C" void vtkQuadraticEdge_destructor (vtkQuadraticEdge * sself) ; +extern "C" int vtk_quadratic_edge_get_cell_type(vtkQuadraticEdge* sself); +extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkQuadraticEdge* sself); +extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkQuadraticEdge* sself); +extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkQuadraticEdge* sself); +extern "C" vtkQuadraticHexahedron * vtkQuadraticHexahedron_new () ; +extern "C" void vtkQuadraticHexahedron_destructor (vtkQuadraticHexahedron * sself) ; +extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkQuadraticHexahedron* sself); +extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkQuadraticHexahedron* sself); +extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkQuadraticHexahedron* sself); +extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkQuadraticHexahedron* sself); +extern "C" vtkQuadraticLinearQuad * vtkQuadraticLinearQuad_new () ; +extern "C" void vtkQuadraticLinearQuad_destructor (vtkQuadraticLinearQuad * sself) ; +extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkQuadraticLinearQuad* sself); +extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkQuadraticLinearQuad* sself); +extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkQuadraticLinearQuad* sself); +extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkQuadraticLinearQuad* sself); +extern "C" vtkQuadraticLinearWedge * vtkQuadraticLinearWedge_new () ; +extern "C" void vtkQuadraticLinearWedge_destructor (vtkQuadraticLinearWedge * sself) ; +extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkQuadraticLinearWedge* sself); +extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkQuadraticLinearWedge* sself); +extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkQuadraticLinearWedge* sself); +extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkQuadraticLinearWedge* sself); +extern "C" vtkQuadraticPolygon * vtkQuadraticPolygon_new () ; +extern "C" void vtkQuadraticPolygon_destructor (vtkQuadraticPolygon * sself) ; +extern "C" int vtk_quadratic_polygon_get_cell_type(vtkQuadraticPolygon* sself); +extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkQuadraticPolygon* sself); +extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkQuadraticPolygon* sself); +extern "C" int vtk_quadratic_polygon_get_number_of_faces(vtkQuadraticPolygon* sself); +extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkQuadraticPolygon* sself); +extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkQuadraticPolygon* sself, bool _arg); +extern "C" vtkQuadraticPyramid * vtkQuadraticPyramid_new () ; +extern "C" void vtkQuadraticPyramid_destructor (vtkQuadraticPyramid * sself) ; +extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkQuadraticPyramid* sself); +extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkQuadraticPyramid* sself); +extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkQuadraticPyramid* sself); +extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkQuadraticPyramid* sself); +extern "C" vtkQuadraticQuad * vtkQuadraticQuad_new () ; +extern "C" void vtkQuadraticQuad_destructor (vtkQuadraticQuad * sself) ; +extern "C" int vtk_quadratic_quad_get_cell_type(vtkQuadraticQuad* sself); +extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkQuadraticQuad* sself); +extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkQuadraticQuad* sself); +extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkQuadraticQuad* sself); +extern "C" vtkQuadraticTetra * vtkQuadraticTetra_new () ; +extern "C" void vtkQuadraticTetra_destructor (vtkQuadraticTetra * sself) ; +extern "C" int vtk_quadratic_tetra_get_cell_type(vtkQuadraticTetra* sself); +extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkQuadraticTetra* sself); +extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkQuadraticTetra* sself); +extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkQuadraticTetra* sself); +extern "C" vtkQuadraticTriangle * vtkQuadraticTriangle_new () ; +extern "C" void vtkQuadraticTriangle_destructor (vtkQuadraticTriangle * sself) ; +extern "C" int vtk_quadratic_triangle_get_cell_type(vtkQuadraticTriangle* sself); +extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkQuadraticTriangle* sself); +extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkQuadraticTriangle* sself); +extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkQuadraticTriangle* sself); +extern "C" vtkQuadraticWedge * vtkQuadraticWedge_new () ; +extern "C" void vtkQuadraticWedge_destructor (vtkQuadraticWedge * sself) ; +extern "C" int vtk_quadratic_wedge_get_cell_type(vtkQuadraticWedge* sself); +extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkQuadraticWedge* sself); +extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkQuadraticWedge* sself); +extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkQuadraticWedge* sself); +extern "C" vtkQuadratureSchemeDefinition * vtkQuadratureSchemeDefinition_new () ; +extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkQuadratureSchemeDefinition * sself) ; +extern "C" void vtk_quadrature_scheme_definition_clear(vtkQuadratureSchemeDefinition* sself); +extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkQuadratureSchemeDefinition* sself); +extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkQuadratureSchemeDefinition* sself); +extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkQuadratureSchemeDefinition* sself); +extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkQuadratureSchemeDefinition* sself); +extern "C" vtkQuadric * vtkQuadric_new () ; +extern "C" void vtkQuadric_destructor (vtkQuadric * sself) ; +extern "C" void vtk_quadric_set_coefficients(vtkQuadric* sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9); +extern "C" vtkRectilinearGrid * vtkRectilinearGrid_new () ; +extern "C" void vtkRectilinearGrid_destructor (vtkRectilinearGrid * sself) ; +extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkRectilinearGrid* sself); +extern "C" void vtk_rectilinear_grid_initialize(vtkRectilinearGrid* sself); +extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkRectilinearGrid* sself); +extern "C" long long vtk_rectilinear_grid_get_number_of_points(vtkRectilinearGrid* sself); +extern "C" int vtk_rectilinear_grid_get_cell_type(vtkRectilinearGrid* sself, long long cellId); +extern "C" int vtk_rectilinear_grid_get_max_cell_size(vtkRectilinearGrid* sself); +extern "C" unsigned char vtk_rectilinear_grid_is_point_visible(vtkRectilinearGrid* sself, long long ptId); +extern "C" unsigned char vtk_rectilinear_grid_is_cell_visible(vtkRectilinearGrid* sself, long long cellId); +extern "C" bool vtk_rectilinear_grid_has_any_blank_points(vtkRectilinearGrid* sself); +extern "C" bool vtk_rectilinear_grid_has_any_blank_cells(vtkRectilinearGrid* sself); +extern "C" void vtk_rectilinear_grid_set_dimensions(vtkRectilinearGrid* sself, int i, int j, int k); +extern "C" int vtk_rectilinear_grid_get_data_dimension(vtkRectilinearGrid* sself); +extern "C" void vtk_rectilinear_grid_set_extent(vtkRectilinearGrid* sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax); +extern "C" int vtk_rectilinear_grid_get_extent_type(vtkRectilinearGrid* sself); +extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkRectilinearGrid* sself); +extern "C" vtkReebGraph * vtkReebGraph_new () ; +extern "C" void vtkReebGraph_destructor (vtkReebGraph * sself) ; +extern "C" int vtk_reeb_graph_stream_triangle(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2); +extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3); +extern "C" void vtk_reeb_graph_close_stream(vtkReebGraph* sself); +extern "C" vtkReebGraphSimplificationMetric * vtkReebGraphSimplificationMetric_new () ; +extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkReebGraphSimplificationMetric * sself) ; +extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkReebGraphSimplificationMetric* sself, double _arg); +extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkReebGraphSimplificationMetric* sself); +extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkReebGraphSimplificationMetric* sself, double _arg); +extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkReebGraphSimplificationMetric* sself); +extern "C" vtkSelection * vtkSelection_new () ; +extern "C" void vtkSelection_destructor (vtkSelection * sself) ; +extern "C" int vtk_selection_get_data_object_type(vtkSelection* sself); +extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkSelection* sself); +extern "C" void vtk_selection_remove_node(vtkSelection* sself, unsigned int idx); +extern "C" void vtk_selection_remove_all_nodes(vtkSelection* sself); +extern "C" void vtk_selection_set_expression(vtkSelection* sself, const char* _arg); +extern "C" unsigned long vtk_selection_get_m_time(vtkSelection* sself); +extern "C" void vtk_selection_dump(vtkSelection* sself); +extern "C" vtkSelectionNode * vtkSelectionNode_new () ; +extern "C" void vtkSelectionNode_destructor (vtkSelectionNode * sself) ; +extern "C" void vtk_selection_node_initialize(vtkSelectionNode* sself); +extern "C" unsigned long vtk_selection_node_get_m_time(vtkSelectionNode* sself); +extern "C" void vtk_selection_node_set_content_type(vtkSelectionNode* sself, int type); +extern "C" int vtk_selection_node_get_content_type(vtkSelectionNode* sself); +extern "C" const char* vtk_selection_node_get_content_type_as_string(vtkSelectionNode* sself, int type); +extern "C" void vtk_selection_node_set_field_type(vtkSelectionNode* sself, int type); +extern "C" int vtk_selection_node_get_field_type(vtkSelectionNode* sself); +extern "C" const char* vtk_selection_node_get_field_type_as_string(vtkSelectionNode* sself, int type); +extern "C" int vtk_selection_node_get_field_type_from_string(vtkSelectionNode* sself, const char* type); +extern "C" int vtk_selection_node_convert_selection_field_to_attribute_type(vtkSelectionNode* sself, int val); +extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkSelectionNode* sself, int val); +extern "C" void vtk_selection_node_set_query_string(vtkSelectionNode* sself, const char* _arg); +extern "C" vtkSimpleCellTessellator * vtkSimpleCellTessellator_new () ; +extern "C" void vtkSimpleCellTessellator_destructor (vtkSimpleCellTessellator * sself) ; +extern "C" void vtk_simple_cell_tessellator_reset(vtkSimpleCellTessellator* sself); +extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkSimpleCellTessellator* sself); +extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkSimpleCellTessellator* sself); +extern "C" int vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(vtkSimpleCellTessellator* sself); +extern "C" void vtk_simple_cell_tessellator_set_fixed_subdivisions(vtkSimpleCellTessellator* sself, int level); +extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkSimpleCellTessellator* sself, int level); +extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkSimpleCellTessellator* sself, int fixed, int maxLevel); +extern "C" vtkSmoothErrorMetric * vtkSmoothErrorMetric_new () ; +extern "C" void vtkSmoothErrorMetric_destructor (vtkSmoothErrorMetric * sself) ; +extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkSmoothErrorMetric* sself); +extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkSmoothErrorMetric* sself, double value); +extern "C" vtkSortFieldData * vtkSortFieldData_new () ; +extern "C" void vtkSortFieldData_destructor (vtkSortFieldData * sself) ; +extern "C" vtkSphere * vtkSphere_new () ; +extern "C" void vtkSphere_destructor (vtkSphere * sself) ; +extern "C" void vtk_sphere_set_radius(vtkSphere* sself, double _arg); +extern "C" double vtk_sphere_get_radius(vtkSphere* sself); +extern "C" void vtk_sphere_set_center(vtkSphere* sself, double _arg1, double _arg2, double _arg3); +extern "C" vtkSpheres * vtkSpheres_new () ; +extern "C" void vtkSpheres_destructor (vtkSpheres * sself) ; +extern "C" int vtk_spheres_get_number_of_spheres(vtkSpheres* sself); +extern "C" vtkStaticCellLinks * vtkStaticCellLinks_new () ; +extern "C" void vtkStaticCellLinks_destructor (vtkStaticCellLinks * sself) ; +extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkStaticCellLinks* sself, long long ptId); +extern "C" long long vtk_static_cell_links_get_ncells(vtkStaticCellLinks* sself, long long ptId); +extern "C" void vtk_static_cell_links_initialize(vtkStaticCellLinks* sself); +extern "C" void vtk_static_cell_links_squeeze(vtkStaticCellLinks* sself); +extern "C" void vtk_static_cell_links_reset(vtkStaticCellLinks* sself); +extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkStaticCellLinks* sself); +extern "C" vtkStaticCellLocator * vtkStaticCellLocator_new () ; +extern "C" void vtkStaticCellLocator_destructor (vtkStaticCellLocator * sself) ; +extern "C" void vtk_static_cell_locator_set_divisions(vtkStaticCellLocator* sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_static_cell_locator_free_search_structure(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_build_locator(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_set_max_number_of_buckets(vtkStaticCellLocator* sself, long long _arg); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_min_value(vtkStaticCellLocator* sself); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_max_value(vtkStaticCellLocator* sself); +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets(vtkStaticCellLocator* sself); +extern "C" bool vtk_static_cell_locator_get_large_ids(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_set_use_diagonal_length_tolerance(vtkStaticCellLocator* sself, bool _arg); +extern "C" bool vtk_static_cell_locator_get_use_diagonal_length_tolerance(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkStaticCellLocator* sself); +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkStaticCellLocator* sself); +extern "C" vtkStaticPointLocator * vtkStaticPointLocator_new () ; +extern "C" void vtkStaticPointLocator_destructor (vtkStaticPointLocator * sself) ; +extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkStaticPointLocator* sself, int _arg); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator* sself); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator* sself); +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket(vtkStaticPointLocator* sself); +extern "C" void vtk_static_point_locator_set_divisions(vtkStaticPointLocator* sself, int _arg1, int _arg2, int _arg3); +extern "C" void vtk_static_point_locator_initialize(vtkStaticPointLocator* sself); +extern "C" void vtk_static_point_locator_free_search_structure(vtkStaticPointLocator* sself); +extern "C" void vtk_static_point_locator_build_locator(vtkStaticPointLocator* sself); +extern "C" long long vtk_static_point_locator_get_number_of_points_in_bucket(vtkStaticPointLocator* sself, long long bNum); +extern "C" void vtk_static_point_locator_set_max_number_of_buckets(vtkStaticPointLocator* sself, long long _arg); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_min_value(vtkStaticPointLocator* sself); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_max_value(vtkStaticPointLocator* sself); +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkStaticPointLocator* sself); +extern "C" bool vtk_static_point_locator_get_large_ids(vtkStaticPointLocator* sself); +extern "C" vtkStaticPointLocator2D * vtkStaticPointLocator2D_new () ; +extern "C" void vtkStaticPointLocator2D_destructor (vtkStaticPointLocator2D * sself) ; +extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkStaticPointLocator2D* sself, int _arg); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator2D* sself); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator2D* sself); +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket(vtkStaticPointLocator2D* sself); +extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkStaticPointLocator2D* sself, int _arg1, int _arg2); +extern "C" void vtk_static_point_locator_2_d_initialize(vtkStaticPointLocator2D* sself); +extern "C" void vtk_static_point_locator_2_d_free_search_structure(vtkStaticPointLocator2D* sself); +extern "C" void vtk_static_point_locator_2_d_build_locator(vtkStaticPointLocator2D* sself); +extern "C" long long vtk_static_point_locator_2_d_get_number_of_points_in_bucket(vtkStaticPointLocator2D* sself, long long bNum); +extern "C" void vtk_static_point_locator_2_d_set_max_number_of_buckets(vtkStaticPointLocator2D* sself, long long _arg); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(vtkStaticPointLocator2D* sself); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(vtkStaticPointLocator2D* sself); +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkStaticPointLocator2D* sself); +extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkStaticPointLocator2D* sself); +extern "C" vtkStructuredExtent * vtkStructuredExtent_new () ; +extern "C" void vtkStructuredExtent_destructor (vtkStructuredExtent * sself) ; +extern "C" vtkStructuredGrid * vtkStructuredGrid_new () ; +extern "C" void vtkStructuredGrid_destructor (vtkStructuredGrid * sself) ; +extern "C" int vtk_structured_grid_get_data_object_type(vtkStructuredGrid* sself); +extern "C" long long vtk_structured_grid_get_number_of_points(vtkStructuredGrid* sself); +extern "C" int vtk_structured_grid_get_cell_type(vtkStructuredGrid* sself, long long cellId); +extern "C" void vtk_structured_grid_set_dimensions(vtkStructuredGrid* sself, int i, int j, int k); +extern "C" int vtk_structured_grid_get_data_dimension(vtkStructuredGrid* sself); +extern "C" void vtk_structured_grid_set_extent(vtkStructuredGrid* sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax); +extern "C" int vtk_structured_grid_get_extent_type(vtkStructuredGrid* sself); +extern "C" void vtk_structured_grid_blank_point(vtkStructuredGrid* sself, long long ptId); +extern "C" void vtk_structured_grid_un_blank_point(vtkStructuredGrid* sself, long long ptId); +extern "C" void vtk_structured_grid_blank_cell(vtkStructuredGrid* sself, long long ptId); +extern "C" void vtk_structured_grid_un_blank_cell(vtkStructuredGrid* sself, long long ptId); +extern "C" unsigned char vtk_structured_grid_is_point_visible(vtkStructuredGrid* sself, long long ptId); +extern "C" unsigned char vtk_structured_grid_is_cell_visible(vtkStructuredGrid* sself, long long cellId); +extern "C" bool vtk_structured_grid_has_any_blank_points(vtkStructuredGrid* sself); +extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkStructuredGrid* sself); +extern "C" vtkStructuredPoints * vtkStructuredPoints_new () ; +extern "C" void vtkStructuredPoints_destructor (vtkStructuredPoints * sself) ; +extern "C" int vtk_structured_points_get_data_object_type(vtkStructuredPoints* sself); +extern "C" vtkStructuredPointsCollection * vtkStructuredPointsCollection_new () ; +extern "C" void vtkStructuredPointsCollection_destructor (vtkStructuredPointsCollection * sself) ; +extern "C" vtkSuperquadric * vtkSuperquadric_new () ; +extern "C" void vtkSuperquadric_destructor (vtkSuperquadric * sself) ; +extern "C" void vtk_superquadric_set_center(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_superquadric_set_scale(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3); +extern "C" double vtk_superquadric_get_thickness(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_set_thickness(vtkSuperquadric* sself, double _arg); +extern "C" double vtk_superquadric_get_thickness_min_value(vtkSuperquadric* sself); +extern "C" double vtk_superquadric_get_thickness_max_value(vtkSuperquadric* sself); +extern "C" double vtk_superquadric_get_phi_roundness(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_set_phi_roundness(vtkSuperquadric* sself, double e); +extern "C" double vtk_superquadric_get_theta_roundness(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_set_theta_roundness(vtkSuperquadric* sself, double e); +extern "C" void vtk_superquadric_set_size(vtkSuperquadric* sself, double _arg); +extern "C" double vtk_superquadric_get_size(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_toroidal_on(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_toroidal_off(vtkSuperquadric* sself); +extern "C" int vtk_superquadric_get_toroidal(vtkSuperquadric* sself); +extern "C" void vtk_superquadric_set_toroidal(vtkSuperquadric* sself, int _arg); +extern "C" vtkTable * vtkTable_new () ; +extern "C" void vtkTable_destructor (vtkTable * sself) ; +extern "C" void vtk_table_dump(vtkTable* sself, unsigned int colWidth, int rowLimit); +extern "C" int vtk_table_get_data_object_type(vtkTable* sself); +extern "C" long long vtk_table_get_number_of_rows(vtkTable* sself); +extern "C" void vtk_table_set_number_of_rows(vtkTable* sself, const long long p0); +extern "C" long long vtk_table_insert_next_blank_row(vtkTable* sself, double default_num_val); +extern "C" void vtk_table_remove_row(vtkTable* sself, long long row); +extern "C" long long vtk_table_get_number_of_columns(vtkTable* sself); +extern "C" const char* vtk_table_get_column_name(vtkTable* sself, long long col); +extern "C" void vtk_table_remove_column_by_name(vtkTable* sself, const char* name); +extern "C" void vtk_table_remove_column(vtkTable* sself, long long col); +extern "C" void vtk_table_initialize(vtkTable* sself); +extern "C" long long vtk_table_get_number_of_elements(vtkTable* sself, int type); +extern "C" vtkTetra * vtkTetra_new () ; +extern "C" void vtkTetra_destructor (vtkTetra * sself) ; +extern "C" int vtk_tetra_get_cell_type(vtkTetra* sself); +extern "C" int vtk_tetra_get_number_of_edges(vtkTetra* sself); +extern "C" int vtk_tetra_get_number_of_faces(vtkTetra* sself); +extern "C" vtkTree * vtkTree_new () ; +extern "C" void vtkTree_destructor (vtkTree * sself) ; +extern "C" long long vtk_tree_get_root(vtkTree* sself); +extern "C" long long vtk_tree_get_number_of_children(vtkTree* sself, long long v); +extern "C" long long vtk_tree_get_child(vtkTree* sself, long long v, long long i); +extern "C" long long vtk_tree_get_parent(vtkTree* sself, long long v); +extern "C" long long vtk_tree_get_level(vtkTree* sself, long long v); +extern "C" bool vtk_tree_is_leaf(vtkTree* sself, long long vertex); +extern "C" vtkTreeBFSIterator * vtkTreeBFSIterator_new () ; +extern "C" void vtkTreeBFSIterator_destructor (vtkTreeBFSIterator * sself) ; +extern "C" vtkTreeDFSIterator * vtkTreeDFSIterator_new () ; +extern "C" void vtkTreeDFSIterator_destructor (vtkTreeDFSIterator * sself) ; +extern "C" void vtk_tree_dfs_iterator_set_mode(vtkTreeDFSIterator* sself, int mode); +extern "C" int vtk_tree_dfs_iterator_get_mode(vtkTreeDFSIterator* sself); +extern "C" vtkTriQuadraticHexahedron * vtkTriQuadraticHexahedron_new () ; +extern "C" void vtkTriQuadraticHexahedron_destructor (vtkTriQuadraticHexahedron * sself) ; +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkTriQuadraticHexahedron* sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkTriQuadraticHexahedron* sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkTriQuadraticHexahedron* sself); +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkTriQuadraticHexahedron* sself); +extern "C" vtkTriQuadraticPyramid * vtkTriQuadraticPyramid_new () ; +extern "C" void vtkTriQuadraticPyramid_destructor (vtkTriQuadraticPyramid * sself) ; +extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkTriQuadraticPyramid* sself); +extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkTriQuadraticPyramid* sself); +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkTriQuadraticPyramid* sself); +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkTriQuadraticPyramid* sself); +extern "C" vtkTriangle * vtkTriangle_new () ; +extern "C" void vtkTriangle_destructor (vtkTriangle * sself) ; +extern "C" int vtk_triangle_get_cell_type(vtkTriangle* sself); +extern "C" int vtk_triangle_get_cell_dimension(vtkTriangle* sself); +extern "C" int vtk_triangle_get_number_of_edges(vtkTriangle* sself); +extern "C" int vtk_triangle_get_number_of_faces(vtkTriangle* sself); +extern "C" double vtk_triangle_compute_area(vtkTriangle* sself); +extern "C" vtkTriangleStrip * vtkTriangleStrip_new () ; +extern "C" void vtkTriangleStrip_destructor (vtkTriangleStrip * sself) ; +extern "C" int vtk_triangle_strip_get_cell_type(vtkTriangleStrip* sself); +extern "C" int vtk_triangle_strip_get_cell_dimension(vtkTriangleStrip* sself); +extern "C" int vtk_triangle_strip_get_number_of_edges(vtkTriangleStrip* sself); +extern "C" int vtk_triangle_strip_get_number_of_faces(vtkTriangleStrip* sself); +extern "C" vtkUndirectedGraph * vtkUndirectedGraph_new () ; +extern "C" void vtkUndirectedGraph_destructor (vtkUndirectedGraph * sself) ; +extern "C" long long vtk_undirected_graph_get_in_degree(vtkUndirectedGraph* sself, long long v); +extern "C" vtkUniformGrid * vtkUniformGrid_new () ; +extern "C" void vtkUniformGrid_destructor (vtkUniformGrid * sself) ; +extern "C" int vtk_uniform_grid_get_grid_description(vtkUniformGrid* sself); +extern "C" void vtk_uniform_grid_blank_point(vtkUniformGrid* sself, long long ptId); +extern "C" void vtk_uniform_grid_un_blank_point(vtkUniformGrid* sself, long long ptId); +extern "C" void vtk_uniform_grid_blank_cell(vtkUniformGrid* sself, long long ptId); +extern "C" void vtk_uniform_grid_un_blank_cell(vtkUniformGrid* sself, long long ptId); +extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkUniformGrid* sself, long long pointId); +extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkUniformGrid* sself, long long cellId); +extern "C" vtkUniformGridAMR * vtkUniformGridAMR_new () ; +extern "C" void vtkUniformGridAMR_destructor (vtkUniformGridAMR * sself) ; +extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkUniformGridAMR* sself); +extern "C" void vtk_uniform_grid_amr_initialize(vtkUniformGridAMR* sself); +extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkUniformGridAMR* sself, int gridDescription); +extern "C" int vtk_uniform_grid_amr_get_grid_description(vtkUniformGridAMR* sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_levels(vtkUniformGridAMR* sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_total_number_of_blocks(vtkUniformGridAMR* sself); +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_data_sets(vtkUniformGridAMR* sself, const unsigned int level); +extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkUniformGridAMR* sself, const unsigned int level, const unsigned int index); +extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkUniformGridAMR* sself, const unsigned int compositeIdx, unsigned int& level, unsigned int& idx); +extern "C" vtkUniformGridAMRDataIterator * vtkUniformGridAMRDataIterator_new () ; +extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkUniformGridAMRDataIterator * sself) ; +extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkUniformGridAMRDataIterator* sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkUniformGridAMRDataIterator* sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkUniformGridAMRDataIterator* sself); +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_index(vtkUniformGridAMRDataIterator* sself); +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_first_item(vtkUniformGridAMRDataIterator* sself); +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkUniformGridAMRDataIterator* sself); +extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkUniformGridAMRDataIterator* sself); +extern "C" vtkUniformHyperTreeGrid * vtkUniformHyperTreeGrid_new () ; +extern "C" void vtkUniformHyperTreeGrid_destructor (vtkUniformHyperTreeGrid * sself) ; +extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkUniformHyperTreeGrid* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkUniformHyperTreeGrid* sself, double p0, double p1, double p2); +extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkUniformHyperTreeGrid* sself); +extern "C" vtkUnstructuredGrid * vtkUnstructuredGrid_new () ; +extern "C" void vtkUnstructuredGrid_destructor (vtkUnstructuredGrid * sself) ; +extern "C" int vtk_unstructured_grid_get_data_object_type(vtkUnstructuredGrid* sself); +extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkUnstructuredGrid* sself, long long numCells, long long maxCellSize); +extern "C" bool vtk_unstructured_grid_allocate_exact(vtkUnstructuredGrid* sself, long long numCells, long long connectivitySize); +extern "C" void vtk_unstructured_grid_allocate(vtkUnstructuredGrid* sself, long long numCells, int extSize); +extern "C" void vtk_unstructured_grid_reset(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_get_cell_type(vtkUnstructuredGrid* sself, long long cellId); +extern "C" void vtk_unstructured_grid_squeeze(vtkUnstructuredGrid* sself); +extern "C" void vtk_unstructured_grid_initialize(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_get_max_cell_size(vtkUnstructuredGrid* sself); +extern "C" void vtk_unstructured_grid_build_links(vtkUnstructuredGrid* sself); +extern "C" void vtk_unstructured_grid_remove_reference_to_cell(vtkUnstructuredGrid* sself, long long ptId, long long cellId); +extern "C" void vtk_unstructured_grid_add_reference_to_cell(vtkUnstructuredGrid* sself, long long ptId, long long cellId); +extern "C" void vtk_unstructured_grid_resize_cell_list(vtkUnstructuredGrid* sself, long long ptId, int size); +extern "C" int vtk_unstructured_grid_get_piece(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_get_number_of_pieces(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_get_ghost_level(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_is_homogeneous(vtkUnstructuredGrid* sself); +extern "C" void vtk_unstructured_grid_remove_ghost_cells(vtkUnstructuredGrid* sself); +extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkUnstructuredGrid* sself, long long numPrevCells); +extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkUnstructuredGrid* sself); +extern "C" vtkUnstructuredGridCellIterator * vtkUnstructuredGridCellIterator_new () ; +extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkUnstructuredGridCellIterator * sself) ; +extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkUnstructuredGridCellIterator* sself); +extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkUnstructuredGridCellIterator* sself); +extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkUnstructuredGridCellIterator* sself, long long cellId); +extern "C" vtkVertex * vtkVertex_new () ; +extern "C" void vtkVertex_destructor (vtkVertex * sself) ; +extern "C" int vtk_vertex_get_cell_type(vtkVertex* sself); +extern "C" int vtk_vertex_get_cell_dimension(vtkVertex* sself); +extern "C" int vtk_vertex_get_number_of_edges(vtkVertex* sself); +extern "C" int vtk_vertex_get_number_of_faces(vtkVertex* sself); +extern "C" int vtk_vertex_inflate(vtkVertex* sself, double p0); +extern "C" vtkVertexListIterator * vtkVertexListIterator_new () ; +extern "C" void vtkVertexListIterator_destructor (vtkVertexListIterator * sself) ; +extern "C" long long vtk_vertex_list_iterator_next(vtkVertexListIterator* sself); +extern "C" bool vtk_vertex_list_iterator_has_next(vtkVertexListIterator* sself); +extern "C" vtkVoxel * vtkVoxel_new () ; +extern "C" void vtkVoxel_destructor (vtkVoxel * sself) ; +extern "C" int vtk_voxel_get_cell_type(vtkVoxel* sself); +extern "C" int vtk_voxel_get_number_of_edges(vtkVoxel* sself); +extern "C" int vtk_voxel_get_number_of_faces(vtkVoxel* sself); +extern "C" int vtk_voxel_inflate(vtkVoxel* sself, double dist); +extern "C" vtkWedge * vtkWedge_new () ; +extern "C" void vtkWedge_destructor (vtkWedge * sself) ; +extern "C" int vtk_wedge_get_cell_type(vtkWedge* sself); +extern "C" int vtk_wedge_get_number_of_edges(vtkWedge* sself); +extern "C" int vtk_wedge_get_number_of_faces(vtkWedge* sself); +extern "C" vtkXMLDataElement * vtkXMLDataElement_new () ; +extern "C" void vtkXMLDataElement_destructor (vtkXMLDataElement * sself) ; +extern "C" void vtk_xml_data_element_set_name(vtkXMLDataElement* sself, const char* _arg); +extern "C" void vtk_xml_data_element_set_id(vtkXMLDataElement* sself, const char* _arg); +extern "C" const char* vtk_xml_data_element_get_attribute(vtkXMLDataElement* sself, const char* name); +extern "C" void vtk_xml_data_element_set_attribute(vtkXMLDataElement* sself, const char* name, const char* value); +extern "C" void vtk_xml_data_element_set_character_data(vtkXMLDataElement* sself, const char* data, int length); +extern "C" void vtk_xml_data_element_add_character_data(vtkXMLDataElement* sself, const char* c, size_t length); +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkXMLDataElement* sself, const char* name, int& value); +extern "C" void vtk_xml_data_element_set_int_attribute(vtkXMLDataElement* sself, const char* name, int value); +extern "C" void vtk_xml_data_element_set_float_attribute(vtkXMLDataElement* sself, const char* name, float value); +extern "C" void vtk_xml_data_element_set_double_attribute(vtkXMLDataElement* sself, const char* name, double value); +extern "C" void vtk_xml_data_element_set_unsigned_long_attribute(vtkXMLDataElement* sself, const char* name, unsigned long value); +extern "C" int vtk_xml_data_element_get_word_type_attribute(vtkXMLDataElement* sself, const char* name, int& value); +extern "C" int vtk_xml_data_element_get_number_of_attributes(vtkXMLDataElement* sself); +extern "C" const char* vtk_xml_data_element_get_attribute_name(vtkXMLDataElement* sself, int idx); +extern "C" const char* vtk_xml_data_element_get_attribute_value(vtkXMLDataElement* sself, int idx); +extern "C" void vtk_xml_data_element_remove_attribute(vtkXMLDataElement* sself, const char* name); +extern "C" void vtk_xml_data_element_remove_all_attributes(vtkXMLDataElement* sself); +extern "C" int vtk_xml_data_element_get_number_of_nested_elements(vtkXMLDataElement* sself); +extern "C" void vtk_xml_data_element_remove_all_nested_elements(vtkXMLDataElement* sself); +extern "C" long long vtk_xml_data_element_get_xml_byte_index(vtkXMLDataElement* sself); +extern "C" void vtk_xml_data_element_set_xml_byte_index(vtkXMLDataElement* sself, long long _arg); +extern "C" void vtk_xml_data_element_set_attribute_encoding(vtkXMLDataElement* sself, int _arg); +extern "C" int vtk_xml_data_element_get_attribute_encoding_min_value(vtkXMLDataElement* sself); +extern "C" int vtk_xml_data_element_get_attribute_encoding_max_value(vtkXMLDataElement* sself); +extern "C" int vtk_xml_data_element_get_attribute_encoding(vtkXMLDataElement* sself); +extern "C" void vtk_xml_data_element_print_xml(vtkXMLDataElement* sself, const char* fname); +extern "C" int vtk_xml_data_element_get_character_data_width(vtkXMLDataElement* sself); +extern "C" void vtk_xml_data_element_set_character_data_width(vtkXMLDataElement* sself, int _arg); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h index 4d4038e..192380b 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_execution_model.h @@ -74,156 +74,268 @@ #include // Declare exported functions -extern "C" vtkNew < vtkAlgorithm > vtkAlgorithm_new () ; -extern "C" void vtkAlgorithm_destructor (vtkNew < vtkAlgorithm > sself) ; -extern "C" void * vtkAlgorithm_get_ptr (vtkNew < vtkAlgorithm > sself) ; -extern "C" vtkNew < vtkAlgorithmOutput > vtkAlgorithmOutput_new () ; -extern "C" void vtkAlgorithmOutput_destructor (vtkNew < vtkAlgorithmOutput > sself) ; -extern "C" void * vtkAlgorithmOutput_get_ptr (vtkNew < vtkAlgorithmOutput > sself) ; -extern "C" vtkNew < vtkAnnotationLayersAlgorithm > vtkAnnotationLayersAlgorithm_new () ; -extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkNew < vtkAnnotationLayersAlgorithm > sself) ; -extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkNew < vtkAnnotationLayersAlgorithm > sself) ; -extern "C" vtkNew < vtkArrayDataAlgorithm > vtkArrayDataAlgorithm_new () ; -extern "C" void vtkArrayDataAlgorithm_destructor (vtkNew < vtkArrayDataAlgorithm > sself) ; -extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkNew < vtkArrayDataAlgorithm > sself) ; -extern "C" vtkNew < vtkCachedStreamingDemandDrivenPipeline > vtkCachedStreamingDemandDrivenPipeline_new () ; -extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) ; -extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) ; -extern "C" vtkNew < vtkCastToConcrete > vtkCastToConcrete_new () ; -extern "C" void vtkCastToConcrete_destructor (vtkNew < vtkCastToConcrete > sself) ; -extern "C" void * vtkCastToConcrete_get_ptr (vtkNew < vtkCastToConcrete > sself) ; -extern "C" vtkNew < vtkCompositeDataPipeline > vtkCompositeDataPipeline_new () ; -extern "C" void vtkCompositeDataPipeline_destructor (vtkNew < vtkCompositeDataPipeline > sself) ; -extern "C" void * vtkCompositeDataPipeline_get_ptr (vtkNew < vtkCompositeDataPipeline > sself) ; -extern "C" vtkNew < vtkCompositeDataSetAlgorithm > vtkCompositeDataSetAlgorithm_new () ; -extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkNew < vtkCompositeDataSetAlgorithm > sself) ; -extern "C" void * vtkCompositeDataSetAlgorithm_get_ptr (vtkNew < vtkCompositeDataSetAlgorithm > sself) ; -extern "C" vtkNew < vtkDataObjectAlgorithm > vtkDataObjectAlgorithm_new () ; -extern "C" void vtkDataObjectAlgorithm_destructor (vtkNew < vtkDataObjectAlgorithm > sself) ; -extern "C" void * vtkDataObjectAlgorithm_get_ptr (vtkNew < vtkDataObjectAlgorithm > sself) ; -extern "C" vtkNew < vtkDataSetAlgorithm > vtkDataSetAlgorithm_new () ; -extern "C" void vtkDataSetAlgorithm_destructor (vtkNew < vtkDataSetAlgorithm > sself) ; -extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkNew < vtkDataSetAlgorithm > sself) ; -extern "C" vtkNew < vtkDemandDrivenPipeline > vtkDemandDrivenPipeline_new () ; -extern "C" void vtkDemandDrivenPipeline_destructor (vtkNew < vtkDemandDrivenPipeline > sself) ; -extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkNew < vtkDemandDrivenPipeline > sself) ; -extern "C" vtkNew < vtkDirectedGraphAlgorithm > vtkDirectedGraphAlgorithm_new () ; -extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkNew < vtkDirectedGraphAlgorithm > sself) ; -extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkNew < vtkDirectedGraphAlgorithm > sself) ; -extern "C" vtkNew < vtkEnsembleSource > vtkEnsembleSource_new () ; -extern "C" void vtkEnsembleSource_destructor (vtkNew < vtkEnsembleSource > sself) ; -extern "C" void * vtkEnsembleSource_get_ptr (vtkNew < vtkEnsembleSource > sself) ; -extern "C" vtkNew < vtkExplicitStructuredGridAlgorithm > vtkExplicitStructuredGridAlgorithm_new () ; -extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) ; -extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) ; -extern "C" vtkNew < vtkExtentRCBPartitioner > vtkExtentRCBPartitioner_new () ; -extern "C" void vtkExtentRCBPartitioner_destructor (vtkNew < vtkExtentRCBPartitioner > sself) ; -extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkNew < vtkExtentRCBPartitioner > sself) ; -extern "C" vtkNew < vtkExtentSplitter > vtkExtentSplitter_new () ; -extern "C" void vtkExtentSplitter_destructor (vtkNew < vtkExtentSplitter > sself) ; -extern "C" void * vtkExtentSplitter_get_ptr (vtkNew < vtkExtentSplitter > sself) ; -extern "C" vtkNew < vtkExtentTranslator > vtkExtentTranslator_new () ; -extern "C" void vtkExtentTranslator_destructor (vtkNew < vtkExtentTranslator > sself) ; -extern "C" void * vtkExtentTranslator_get_ptr (vtkNew < vtkExtentTranslator > sself) ; -extern "C" vtkNew < vtkGraphAlgorithm > vtkGraphAlgorithm_new () ; -extern "C" void vtkGraphAlgorithm_destructor (vtkNew < vtkGraphAlgorithm > sself) ; -extern "C" void * vtkGraphAlgorithm_get_ptr (vtkNew < vtkGraphAlgorithm > sself) ; -extern "C" vtkNew < vtkHierarchicalBoxDataSetAlgorithm > vtkHierarchicalBoxDataSetAlgorithm_new () ; -extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkNew < vtkHierarchicalBoxDataSetAlgorithm > sself) ; -extern "C" void * vtkHierarchicalBoxDataSetAlgorithm_get_ptr (vtkNew < vtkHierarchicalBoxDataSetAlgorithm > sself) ; -extern "C" vtkNew < vtkImageToStructuredGrid > vtkImageToStructuredGrid_new () ; -extern "C" void vtkImageToStructuredGrid_destructor (vtkNew < vtkImageToStructuredGrid > sself) ; -extern "C" void * vtkImageToStructuredGrid_get_ptr (vtkNew < vtkImageToStructuredGrid > sself) ; -extern "C" vtkNew < vtkImageToStructuredPoints > vtkImageToStructuredPoints_new () ; -extern "C" void vtkImageToStructuredPoints_destructor (vtkNew < vtkImageToStructuredPoints > sself) ; -extern "C" void * vtkImageToStructuredPoints_get_ptr (vtkNew < vtkImageToStructuredPoints > sself) ; -extern "C" vtkNew < vtkMoleculeAlgorithm > vtkMoleculeAlgorithm_new () ; -extern "C" void vtkMoleculeAlgorithm_destructor (vtkNew < vtkMoleculeAlgorithm > sself) ; -extern "C" void * vtkMoleculeAlgorithm_get_ptr (vtkNew < vtkMoleculeAlgorithm > sself) ; -extern "C" vtkNew < vtkMultiBlockDataSetAlgorithm > vtkMultiBlockDataSetAlgorithm_new () ; -extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkNew < vtkMultiBlockDataSetAlgorithm > sself) ; -extern "C" void * vtkMultiBlockDataSetAlgorithm_get_ptr (vtkNew < vtkMultiBlockDataSetAlgorithm > sself) ; -extern "C" vtkNew < vtkMultiTimeStepAlgorithm > vtkMultiTimeStepAlgorithm_new () ; -extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkNew < vtkMultiTimeStepAlgorithm > sself) ; -extern "C" void * vtkMultiTimeStepAlgorithm_get_ptr (vtkNew < vtkMultiTimeStepAlgorithm > sself) ; -extern "C" vtkNew < vtkNonOverlappingAMRAlgorithm > vtkNonOverlappingAMRAlgorithm_new () ; -extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNew < vtkNonOverlappingAMRAlgorithm > sself) ; -extern "C" void * vtkNonOverlappingAMRAlgorithm_get_ptr (vtkNew < vtkNonOverlappingAMRAlgorithm > sself) ; -extern "C" vtkNew < vtkOverlappingAMRAlgorithm > vtkOverlappingAMRAlgorithm_new () ; -extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkNew < vtkOverlappingAMRAlgorithm > sself) ; -extern "C" void * vtkOverlappingAMRAlgorithm_get_ptr (vtkNew < vtkOverlappingAMRAlgorithm > sself) ; -extern "C" vtkNew < vtkPassInputTypeAlgorithm > vtkPassInputTypeAlgorithm_new () ; -extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkNew < vtkPassInputTypeAlgorithm > sself) ; -extern "C" void * vtkPassInputTypeAlgorithm_get_ptr (vtkNew < vtkPassInputTypeAlgorithm > sself) ; -extern "C" vtkNew < vtkPiecewiseFunctionAlgorithm > vtkPiecewiseFunctionAlgorithm_new () ; -extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkNew < vtkPiecewiseFunctionAlgorithm > sself) ; -extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkNew < vtkPiecewiseFunctionAlgorithm > sself) ; -extern "C" vtkNew < vtkPiecewiseFunctionShiftScale > vtkPiecewiseFunctionShiftScale_new () ; -extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkNew < vtkPiecewiseFunctionShiftScale > sself) ; -extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkNew < vtkPiecewiseFunctionShiftScale > sself) ; -extern "C" vtkNew < vtkPointSetAlgorithm > vtkPointSetAlgorithm_new () ; -extern "C" void vtkPointSetAlgorithm_destructor (vtkNew < vtkPointSetAlgorithm > sself) ; -extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkNew < vtkPointSetAlgorithm > sself) ; -extern "C" vtkNew < vtkPolyDataAlgorithm > vtkPolyDataAlgorithm_new () ; -extern "C" void vtkPolyDataAlgorithm_destructor (vtkNew < vtkPolyDataAlgorithm > sself) ; -extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkNew < vtkPolyDataAlgorithm > sself) ; -extern "C" vtkNew < vtkProgressObserver > vtkProgressObserver_new () ; -extern "C" void vtkProgressObserver_destructor (vtkNew < vtkProgressObserver > sself) ; -extern "C" void * vtkProgressObserver_get_ptr (vtkNew < vtkProgressObserver > sself) ; -extern "C" vtkNew < vtkReaderExecutive > vtkReaderExecutive_new () ; -extern "C" void vtkReaderExecutive_destructor (vtkNew < vtkReaderExecutive > sself) ; -extern "C" void * vtkReaderExecutive_get_ptr (vtkNew < vtkReaderExecutive > sself) ; -extern "C" vtkNew < vtkRectilinearGridAlgorithm > vtkRectilinearGridAlgorithm_new () ; -extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkNew < vtkRectilinearGridAlgorithm > sself) ; -extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkNew < vtkRectilinearGridAlgorithm > sself) ; -extern "C" vtkNew < vtkSMPProgressObserver > vtkSMPProgressObserver_new () ; -extern "C" void vtkSMPProgressObserver_destructor (vtkNew < vtkSMPProgressObserver > sself) ; -extern "C" void * vtkSMPProgressObserver_get_ptr (vtkNew < vtkSMPProgressObserver > sself) ; -extern "C" vtkNew < vtkSelectionAlgorithm > vtkSelectionAlgorithm_new () ; -extern "C" void vtkSelectionAlgorithm_destructor (vtkNew < vtkSelectionAlgorithm > sself) ; -extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkNew < vtkSelectionAlgorithm > sself) ; -extern "C" vtkNew < vtkSimpleScalarTree > vtkSimpleScalarTree_new () ; -extern "C" void vtkSimpleScalarTree_destructor (vtkNew < vtkSimpleScalarTree > sself) ; -extern "C" void * vtkSimpleScalarTree_get_ptr (vtkNew < vtkSimpleScalarTree > sself) ; -extern "C" vtkNew < vtkSpanSpace > vtkSpanSpace_new () ; -extern "C" void vtkSpanSpace_destructor (vtkNew < vtkSpanSpace > sself) ; -extern "C" void * vtkSpanSpace_get_ptr (vtkNew < vtkSpanSpace > sself) ; -extern "C" vtkNew < vtkSphereTree > vtkSphereTree_new () ; -extern "C" void vtkSphereTree_destructor (vtkNew < vtkSphereTree > sself) ; -extern "C" void * vtkSphereTree_get_ptr (vtkNew < vtkSphereTree > sself) ; -extern "C" vtkNew < vtkStreamingDemandDrivenPipeline > vtkStreamingDemandDrivenPipeline_new () ; -extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkNew < vtkStreamingDemandDrivenPipeline > sself) ; -extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkStreamingDemandDrivenPipeline > sself) ; -extern "C" vtkNew < vtkStructuredGridAlgorithm > vtkStructuredGridAlgorithm_new () ; -extern "C" void vtkStructuredGridAlgorithm_destructor (vtkNew < vtkStructuredGridAlgorithm > sself) ; -extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkNew < vtkStructuredGridAlgorithm > sself) ; -extern "C" vtkNew < vtkTableAlgorithm > vtkTableAlgorithm_new () ; -extern "C" void vtkTableAlgorithm_destructor (vtkNew < vtkTableAlgorithm > sself) ; -extern "C" void * vtkTableAlgorithm_get_ptr (vtkNew < vtkTableAlgorithm > sself) ; -extern "C" vtkNew < vtkThreadedCompositeDataPipeline > vtkThreadedCompositeDataPipeline_new () ; -extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkNew < vtkThreadedCompositeDataPipeline > sself) ; -extern "C" void * vtkThreadedCompositeDataPipeline_get_ptr (vtkNew < vtkThreadedCompositeDataPipeline > sself) ; -extern "C" vtkNew < vtkTreeAlgorithm > vtkTreeAlgorithm_new () ; -extern "C" void vtkTreeAlgorithm_destructor (vtkNew < vtkTreeAlgorithm > sself) ; -extern "C" void * vtkTreeAlgorithm_get_ptr (vtkNew < vtkTreeAlgorithm > sself) ; -extern "C" vtkNew < vtkTrivialConsumer > vtkTrivialConsumer_new () ; -extern "C" void vtkTrivialConsumer_destructor (vtkNew < vtkTrivialConsumer > sself) ; -extern "C" void * vtkTrivialConsumer_get_ptr (vtkNew < vtkTrivialConsumer > sself) ; -extern "C" vtkNew < vtkTrivialProducer > vtkTrivialProducer_new () ; -extern "C" void vtkTrivialProducer_destructor (vtkNew < vtkTrivialProducer > sself) ; -extern "C" void * vtkTrivialProducer_get_ptr (vtkNew < vtkTrivialProducer > sself) ; -extern "C" vtkNew < vtkUndirectedGraphAlgorithm > vtkUndirectedGraphAlgorithm_new () ; -extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkNew < vtkUndirectedGraphAlgorithm > sself) ; -extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkNew < vtkUndirectedGraphAlgorithm > sself) ; -extern "C" vtkNew < vtkUniformGridAMRAlgorithm > vtkUniformGridAMRAlgorithm_new () ; -extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkNew < vtkUniformGridAMRAlgorithm > sself) ; -extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkNew < vtkUniformGridAMRAlgorithm > sself) ; -extern "C" vtkNew < vtkUniformGridPartitioner > vtkUniformGridPartitioner_new () ; -extern "C" void vtkUniformGridPartitioner_destructor (vtkNew < vtkUniformGridPartitioner > sself) ; -extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkNew < vtkUniformGridPartitioner > sself) ; -extern "C" vtkNew < vtkUnstructuredGridAlgorithm > vtkUnstructuredGridAlgorithm_new () ; -extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkNew < vtkUnstructuredGridAlgorithm > sself) ; -extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridAlgorithm > sself) ; -extern "C" vtkNew < vtkUnstructuredGridBaseAlgorithm > vtkUnstructuredGridBaseAlgorithm_new () ; -extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkNew < vtkUnstructuredGridBaseAlgorithm > sself) ; -extern "C" void * vtkUnstructuredGridBaseAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridBaseAlgorithm > sself) ; +extern "C" vtkAlgorithm * vtkAlgorithm_new () ; +extern "C" void vtkAlgorithm_destructor (vtkAlgorithm * sself) ; +extern "C" int vtk_algorithm_has_executive(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_number_of_input_ports(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_number_of_output_ports(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_set_abort_execute(vtkAlgorithm* sself, int _arg); +extern "C" int vtk_algorithm_get_abort_execute(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_abort_execute_on(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_abort_execute_off(vtkAlgorithm* sself); +extern "C" double vtk_algorithm_get_progress(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_set_progress(vtkAlgorithm* sself, double p0); +extern "C" void vtk_algorithm_update_progress(vtkAlgorithm* sself, double amount); +extern "C" void vtk_algorithm_set_progress_shift_scale(vtkAlgorithm* sself, double shift, double scale); +extern "C" double vtk_algorithm_get_progress_shift(vtkAlgorithm* sself); +extern "C" double vtk_algorithm_get_progress_scale(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_set_progress_text(vtkAlgorithm* sself, const char* ptext); +extern "C" unsigned long vtk_algorithm_get_error_code(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_set_input_array_to_process(vtkAlgorithm* sself, int idx, int port, int connection, int fieldAssociation, const char* name); +extern "C" void vtk_algorithm_remove_all_inputs(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_remove_all_input_connections(vtkAlgorithm* sself, int port); +extern "C" int vtk_algorithm_get_number_of_input_connections(vtkAlgorithm* sself, int port); +extern "C" int vtk_algorithm_get_total_number_of_input_connections(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_update(vtkAlgorithm* sself, int port); +extern "C" void vtk_algorithm_update_information(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_update_data_object(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_propagate_update_extent(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_update_whole_extent(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_convert_total_input_to_port_connection(vtkAlgorithm* sself, int ind, int& port, int& conn); +extern "C" void vtk_algorithm_set_release_data_flag(vtkAlgorithm* sself, int p0); +extern "C" int vtk_algorithm_get_release_data_flag(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_release_data_flag_on(vtkAlgorithm* sself); +extern "C" void vtk_algorithm_release_data_flag_off(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_update_piece(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkAlgorithm* sself); +extern "C" int vtk_algorithm_get_update_ghost_level(vtkAlgorithm* sself); +extern "C" vtkAlgorithmOutput * vtkAlgorithmOutput_new () ; +extern "C" void vtkAlgorithmOutput_destructor (vtkAlgorithmOutput * sself) ; +extern "C" void vtk_algorithm_output_set_index(vtkAlgorithmOutput* sself, int index); +extern "C" int vtk_algorithm_output_get_index(vtkAlgorithmOutput* sself); +extern "C" vtkAnnotationLayersAlgorithm * vtkAnnotationLayersAlgorithm_new () ; +extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkAnnotationLayersAlgorithm * sself) ; +extern "C" vtkArrayDataAlgorithm * vtkArrayDataAlgorithm_new () ; +extern "C" void vtkArrayDataAlgorithm_destructor (vtkArrayDataAlgorithm * sself) ; +extern "C" vtkCachedStreamingDemandDrivenPipeline * vtkCachedStreamingDemandDrivenPipeline_new () ; +extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkCachedStreamingDemandDrivenPipeline * sself) ; +extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself, int size); +extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself); +extern "C" vtkCastToConcrete * vtkCastToConcrete_new () ; +extern "C" void vtkCastToConcrete_destructor (vtkCastToConcrete * sself) ; +extern "C" vtkCompositeDataPipeline * vtkCompositeDataPipeline_new () ; +extern "C" void vtkCompositeDataPipeline_destructor (vtkCompositeDataPipeline * sself) ; +extern "C" vtkCompositeDataSetAlgorithm * vtkCompositeDataSetAlgorithm_new () ; +extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkCompositeDataSetAlgorithm * sself) ; +extern "C" vtkDataObjectAlgorithm * vtkDataObjectAlgorithm_new () ; +extern "C" void vtkDataObjectAlgorithm_destructor (vtkDataObjectAlgorithm * sself) ; +extern "C" vtkDataSetAlgorithm * vtkDataSetAlgorithm_new () ; +extern "C" void vtkDataSetAlgorithm_destructor (vtkDataSetAlgorithm * sself) ; +extern "C" vtkDemandDrivenPipeline * vtkDemandDrivenPipeline_new () ; +extern "C" void vtkDemandDrivenPipeline_destructor (vtkDemandDrivenPipeline * sself) ; +extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkDemandDrivenPipeline* sself); +extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkDemandDrivenPipeline* sself, int port, int n); +extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkDemandDrivenPipeline* sself, int port); +extern "C" int vtk_demand_driven_pipeline_update_pipeline_m_time(vtkDemandDrivenPipeline* sself); +extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkDemandDrivenPipeline* sself); +extern "C" int vtk_demand_driven_pipeline_update_data(vtkDemandDrivenPipeline* sself, int outputPort); +extern "C" vtkDirectedGraphAlgorithm * vtkDirectedGraphAlgorithm_new () ; +extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkDirectedGraphAlgorithm * sself) ; +extern "C" vtkEnsembleSource * vtkEnsembleSource_new () ; +extern "C" void vtkEnsembleSource_destructor (vtkEnsembleSource * sself) ; +extern "C" void vtk_ensemble_source_remove_all_members(vtkEnsembleSource* sself); +extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkEnsembleSource* sself); +extern "C" void vtk_ensemble_source_set_current_member(vtkEnsembleSource* sself, unsigned int _arg); +extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkEnsembleSource* sself); +extern "C" vtkExplicitStructuredGridAlgorithm * vtkExplicitStructuredGridAlgorithm_new () ; +extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkExplicitStructuredGridAlgorithm * sself) ; +extern "C" vtkExtentRCBPartitioner * vtkExtentRCBPartitioner_new () ; +extern "C" void vtkExtentRCBPartitioner_destructor (vtkExtentRCBPartitioner * sself) ; +extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkExtentRCBPartitioner* sself, const int N); +extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkExtentRCBPartitioner* sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax); +extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkExtentRCBPartitioner* sself, int _arg); +extern "C" int vtk_extent_rcb_partitioner_get_duplicate_nodes(vtkExtentRCBPartitioner* sself); +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_on(vtkExtentRCBPartitioner* sself); +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_off(vtkExtentRCBPartitioner* sself); +extern "C" void vtk_extent_rcb_partitioner_set_number_of_ghost_layers(vtkExtentRCBPartitioner* sself, int _arg); +extern "C" int vtk_extent_rcb_partitioner_get_number_of_ghost_layers(vtkExtentRCBPartitioner* sself); +extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkExtentRCBPartitioner* sself); +extern "C" void vtk_extent_rcb_partitioner_partition(vtkExtentRCBPartitioner* sself); +extern "C" vtkExtentSplitter * vtkExtentSplitter_new () ; +extern "C" void vtkExtentSplitter_destructor (vtkExtentSplitter * sself) ; +extern "C" void vtk_extent_splitter_add_extent_source(vtkExtentSplitter* sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" void vtk_extent_splitter_remove_extent_source(vtkExtentSplitter* sself, int id); +extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkExtentSplitter* sself); +extern "C" void vtk_extent_splitter_add_extent(vtkExtentSplitter* sself, int x0, int x1, int y0, int y1, int z0, int z1); +extern "C" int vtk_extent_splitter_compute_sub_extents(vtkExtentSplitter* sself); +extern "C" int vtk_extent_splitter_get_number_of_sub_extents(vtkExtentSplitter* sself); +extern "C" int vtk_extent_splitter_get_sub_extent_source(vtkExtentSplitter* sself, int index); +extern "C" int vtk_extent_splitter_get_point_mode(vtkExtentSplitter* sself); +extern "C" void vtk_extent_splitter_set_point_mode(vtkExtentSplitter* sself, int _arg); +extern "C" void vtk_extent_splitter_point_mode_on(vtkExtentSplitter* sself); +extern "C" void vtk_extent_splitter_point_mode_off(vtkExtentSplitter* sself); +extern "C" vtkExtentTranslator * vtkExtentTranslator_new () ; +extern "C" void vtkExtentTranslator_destructor (vtkExtentTranslator * sself) ; +extern "C" void vtk_extent_translator_set_whole_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extent_translator_set_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" void vtk_extent_translator_set_piece(vtkExtentTranslator* sself, int _arg); +extern "C" int vtk_extent_translator_get_piece(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_number_of_pieces(vtkExtentTranslator* sself, int _arg); +extern "C" int vtk_extent_translator_get_number_of_pieces(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_ghost_level(vtkExtentTranslator* sself, int _arg); +extern "C" int vtk_extent_translator_get_ghost_level(vtkExtentTranslator* sself); +extern "C" int vtk_extent_translator_piece_to_extent(vtkExtentTranslator* sself); +extern "C" int vtk_extent_translator_piece_to_extent_by_points(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_split_mode_to_block(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_split_mode_to_x_slab(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_split_mode_to_y_slab(vtkExtentTranslator* sself); +extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkExtentTranslator* sself); +extern "C" int vtk_extent_translator_get_split_mode(vtkExtentTranslator* sself); +extern "C" vtkGraphAlgorithm * vtkGraphAlgorithm_new () ; +extern "C" void vtkGraphAlgorithm_destructor (vtkGraphAlgorithm * sself) ; +extern "C" vtkHierarchicalBoxDataSetAlgorithm * vtkHierarchicalBoxDataSetAlgorithm_new () ; +extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkHierarchicalBoxDataSetAlgorithm * sself) ; +extern "C" vtkImageToStructuredGrid * vtkImageToStructuredGrid_new () ; +extern "C" void vtkImageToStructuredGrid_destructor (vtkImageToStructuredGrid * sself) ; +extern "C" vtkImageToStructuredPoints * vtkImageToStructuredPoints_new () ; +extern "C" void vtkImageToStructuredPoints_destructor (vtkImageToStructuredPoints * sself) ; +extern "C" vtkMoleculeAlgorithm * vtkMoleculeAlgorithm_new () ; +extern "C" void vtkMoleculeAlgorithm_destructor (vtkMoleculeAlgorithm * sself) ; +extern "C" vtkMultiBlockDataSetAlgorithm * vtkMultiBlockDataSetAlgorithm_new () ; +extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkMultiBlockDataSetAlgorithm * sself) ; +extern "C" vtkMultiTimeStepAlgorithm * vtkMultiTimeStepAlgorithm_new () ; +extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkMultiTimeStepAlgorithm * sself) ; +extern "C" vtkNonOverlappingAMRAlgorithm * vtkNonOverlappingAMRAlgorithm_new () ; +extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNonOverlappingAMRAlgorithm * sself) ; +extern "C" vtkOverlappingAMRAlgorithm * vtkOverlappingAMRAlgorithm_new () ; +extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkOverlappingAMRAlgorithm * sself) ; +extern "C" vtkPassInputTypeAlgorithm * vtkPassInputTypeAlgorithm_new () ; +extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkPassInputTypeAlgorithm * sself) ; +extern "C" vtkPiecewiseFunctionAlgorithm * vtkPiecewiseFunctionAlgorithm_new () ; +extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkPiecewiseFunctionAlgorithm * sself) ; +extern "C" vtkPiecewiseFunctionShiftScale * vtkPiecewiseFunctionShiftScale_new () ; +extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkPiecewiseFunctionShiftScale * sself) ; +extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg); +extern "C" void vtk_piecewise_function_shift_scale_set_value_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg); +extern "C" double vtk_piecewise_function_shift_scale_get_position_shift(vtkPiecewiseFunctionShiftScale* sself); +extern "C" double vtk_piecewise_function_shift_scale_get_position_scale(vtkPiecewiseFunctionShiftScale* sself); +extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkPiecewiseFunctionShiftScale* sself); +extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkPiecewiseFunctionShiftScale* sself); +extern "C" vtkPointSetAlgorithm * vtkPointSetAlgorithm_new () ; +extern "C" void vtkPointSetAlgorithm_destructor (vtkPointSetAlgorithm * sself) ; +extern "C" vtkPolyDataAlgorithm * vtkPolyDataAlgorithm_new () ; +extern "C" void vtkPolyDataAlgorithm_destructor (vtkPolyDataAlgorithm * sself) ; +extern "C" vtkProgressObserver * vtkProgressObserver_new () ; +extern "C" void vtkProgressObserver_destructor (vtkProgressObserver * sself) ; +extern "C" void vtk_progress_observer_update_progress(vtkProgressObserver* sself, double amount); +extern "C" double vtk_progress_observer_get_progress(vtkProgressObserver* sself); +extern "C" vtkReaderExecutive * vtkReaderExecutive_new () ; +extern "C" void vtkReaderExecutive_destructor (vtkReaderExecutive * sself) ; +extern "C" vtkRectilinearGridAlgorithm * vtkRectilinearGridAlgorithm_new () ; +extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkRectilinearGridAlgorithm * sself) ; +extern "C" vtkSMPProgressObserver * vtkSMPProgressObserver_new () ; +extern "C" void vtkSMPProgressObserver_destructor (vtkSMPProgressObserver * sself) ; +extern "C" void vtk_smp_progress_observer_update_progress(vtkSMPProgressObserver* sself, double progress); +extern "C" vtkSelectionAlgorithm * vtkSelectionAlgorithm_new () ; +extern "C" void vtkSelectionAlgorithm_destructor (vtkSelectionAlgorithm * sself) ; +extern "C" vtkSimpleScalarTree * vtkSimpleScalarTree_new () ; +extern "C" void vtkSimpleScalarTree_destructor (vtkSimpleScalarTree * sself) ; +extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkSimpleScalarTree* sself, int _arg); +extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_branching_factor(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_level(vtkSimpleScalarTree* sself); +extern "C" void vtk_simple_scalar_tree_set_max_level(vtkSimpleScalarTree* sself, int _arg); +extern "C" int vtk_simple_scalar_tree_get_max_level_min_value(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_max_level_max_value(vtkSimpleScalarTree* sself); +extern "C" int vtk_simple_scalar_tree_get_max_level(vtkSimpleScalarTree* sself); +extern "C" void vtk_simple_scalar_tree_build_tree(vtkSimpleScalarTree* sself); +extern "C" void vtk_simple_scalar_tree_initialize(vtkSimpleScalarTree* sself); +extern "C" void vtk_simple_scalar_tree_init_traversal(vtkSimpleScalarTree* sself, double scalarValue); +extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkSimpleScalarTree* sself, double scalarValue); +extern "C" vtkSpanSpace * vtkSpanSpace_new () ; +extern "C" void vtkSpanSpace_destructor (vtkSpanSpace * sself) ; +extern "C" void vtk_span_space_set_scalar_range(vtkSpanSpace* sself, double _arg1, double _arg2); +extern "C" void vtk_span_space_set_compute_scalar_range(vtkSpanSpace* sself, int _arg); +extern "C" int vtk_span_space_get_compute_scalar_range(vtkSpanSpace* sself); +extern "C" void vtk_span_space_compute_scalar_range_on(vtkSpanSpace* sself); +extern "C" void vtk_span_space_compute_scalar_range_off(vtkSpanSpace* sself); +extern "C" void vtk_span_space_set_resolution(vtkSpanSpace* sself, long long _arg); +extern "C" long long vtk_span_space_get_resolution_min_value(vtkSpanSpace* sself); +extern "C" long long vtk_span_space_get_resolution_max_value(vtkSpanSpace* sself); +extern "C" long long vtk_span_space_get_resolution(vtkSpanSpace* sself); +extern "C" void vtk_span_space_set_compute_resolution(vtkSpanSpace* sself, int _arg); +extern "C" int vtk_span_space_get_compute_resolution(vtkSpanSpace* sself); +extern "C" void vtk_span_space_compute_resolution_on(vtkSpanSpace* sself); +extern "C" void vtk_span_space_compute_resolution_off(vtkSpanSpace* sself); +extern "C" void vtk_span_space_set_number_of_cells_per_bucket(vtkSpanSpace* sself, int _arg); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_min_value(vtkSpanSpace* sself); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_max_value(vtkSpanSpace* sself); +extern "C" int vtk_span_space_get_number_of_cells_per_bucket(vtkSpanSpace* sself); +extern "C" void vtk_span_space_initialize(vtkSpanSpace* sself); +extern "C" void vtk_span_space_build_tree(vtkSpanSpace* sself); +extern "C" void vtk_span_space_init_traversal(vtkSpanSpace* sself, double scalarValue); +extern "C" long long vtk_span_space_get_number_of_cell_batches(vtkSpanSpace* sself, double scalarValue); +extern "C" void vtk_span_space_set_batch_size(vtkSpanSpace* sself, long long _arg); +extern "C" long long vtk_span_space_get_batch_size_min_value(vtkSpanSpace* sself); +extern "C" long long vtk_span_space_get_batch_size_max_value(vtkSpanSpace* sself); +extern "C" long long vtk_span_space_get_batch_size(vtkSpanSpace* sself); +extern "C" vtkSphereTree * vtkSphereTree_new () ; +extern "C" void vtkSphereTree_destructor (vtkSphereTree * sself) ; +extern "C" void vtk_sphere_tree_build(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkSphereTree* sself, bool _arg); +extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_build_hierarchy_on(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_build_hierarchy_off(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_set_resolution(vtkSphereTree* sself, int _arg); +extern "C" int vtk_sphere_tree_get_resolution_min_value(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_resolution_max_value(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_resolution(vtkSphereTree* sself); +extern "C" void vtk_sphere_tree_set_max_level(vtkSphereTree* sself, int _arg); +extern "C" int vtk_sphere_tree_get_max_level_min_value(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_max_level_max_value(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_max_level(vtkSphereTree* sself); +extern "C" int vtk_sphere_tree_get_number_of_levels(vtkSphereTree* sself); +extern "C" vtkStreamingDemandDrivenPipeline * vtkStreamingDemandDrivenPipeline_new () ; +extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkStreamingDemandDrivenPipeline * sself) ; +extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkStreamingDemandDrivenPipeline* sself); +extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkStreamingDemandDrivenPipeline* sself); +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkStreamingDemandDrivenPipeline* sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_time(vtkStreamingDemandDrivenPipeline* sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_update_time_dependent_information(vtkStreamingDemandDrivenPipeline* sself, int outputPort); +extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port, int flag); +extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port); +extern "C" vtkStructuredGridAlgorithm * vtkStructuredGridAlgorithm_new () ; +extern "C" void vtkStructuredGridAlgorithm_destructor (vtkStructuredGridAlgorithm * sself) ; +extern "C" vtkTableAlgorithm * vtkTableAlgorithm_new () ; +extern "C" void vtkTableAlgorithm_destructor (vtkTableAlgorithm * sself) ; +extern "C" vtkThreadedCompositeDataPipeline * vtkThreadedCompositeDataPipeline_new () ; +extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkThreadedCompositeDataPipeline * sself) ; +extern "C" vtkTreeAlgorithm * vtkTreeAlgorithm_new () ; +extern "C" void vtkTreeAlgorithm_destructor (vtkTreeAlgorithm * sself) ; +extern "C" vtkTrivialConsumer * vtkTrivialConsumer_new () ; +extern "C" void vtkTrivialConsumer_destructor (vtkTrivialConsumer * sself) ; +extern "C" vtkTrivialProducer * vtkTrivialProducer_new () ; +extern "C" void vtkTrivialProducer_destructor (vtkTrivialProducer * sself) ; +extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkTrivialProducer* sself); +extern "C" void vtk_trivial_producer_set_whole_extent(vtkTrivialProducer* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6); +extern "C" vtkUndirectedGraphAlgorithm * vtkUndirectedGraphAlgorithm_new () ; +extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkUndirectedGraphAlgorithm * sself) ; +extern "C" vtkUniformGridAMRAlgorithm * vtkUniformGridAMRAlgorithm_new () ; +extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkUniformGridAMRAlgorithm * sself) ; +extern "C" vtkUniformGridPartitioner * vtkUniformGridPartitioner_new () ; +extern "C" void vtkUniformGridPartitioner_destructor (vtkUniformGridPartitioner * sself) ; +extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkUniformGridPartitioner* sself); +extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkUniformGridPartitioner* sself, int _arg); +extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkUniformGridPartitioner* sself); +extern "C" void vtk_uniform_grid_partitioner_set_number_of_ghost_layers(vtkUniformGridPartitioner* sself, int _arg); +extern "C" int vtk_uniform_grid_partitioner_get_duplicate_nodes(vtkUniformGridPartitioner* sself); +extern "C" void vtk_uniform_grid_partitioner_set_duplicate_nodes(vtkUniformGridPartitioner* sself, int _arg); +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkUniformGridPartitioner* sself); +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkUniformGridPartitioner* sself); +extern "C" vtkUnstructuredGridAlgorithm * vtkUnstructuredGridAlgorithm_new () ; +extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkUnstructuredGridAlgorithm * sself) ; +extern "C" vtkUnstructuredGridBaseAlgorithm * vtkUnstructuredGridBaseAlgorithm_new () ; +extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkUnstructuredGridBaseAlgorithm * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h index b1c918d..7935d72 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_math.h @@ -20,30 +20,81 @@ #include // Declare exported functions -extern "C" vtkNew < vtkAmoebaMinimizer > vtkAmoebaMinimizer_new () ; -extern "C" void vtkAmoebaMinimizer_destructor (vtkNew < vtkAmoebaMinimizer > sself) ; -extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkNew < vtkAmoebaMinimizer > sself) ; -extern "C" vtkNew < vtkFFT > vtkFFT_new () ; -extern "C" void vtkFFT_destructor (vtkNew < vtkFFT > sself) ; -extern "C" void * vtkFFT_get_ptr (vtkNew < vtkFFT > sself) ; -extern "C" vtkNew < vtkMatrix3x3 > vtkMatrix3x3_new () ; -extern "C" void vtkMatrix3x3_destructor (vtkNew < vtkMatrix3x3 > sself) ; -extern "C" void * vtkMatrix3x3_get_ptr (vtkNew < vtkMatrix3x3 > sself) ; -extern "C" vtkNew < vtkMatrix4x4 > vtkMatrix4x4_new () ; -extern "C" void vtkMatrix4x4_destructor (vtkNew < vtkMatrix4x4 > sself) ; -extern "C" void * vtkMatrix4x4_get_ptr (vtkNew < vtkMatrix4x4 > sself) ; -extern "C" vtkNew < vtkPolynomialSolversUnivariate > vtkPolynomialSolversUnivariate_new () ; -extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkNew < vtkPolynomialSolversUnivariate > sself) ; -extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkNew < vtkPolynomialSolversUnivariate > sself) ; -extern "C" vtkNew < vtkQuaternionInterpolator > vtkQuaternionInterpolator_new () ; -extern "C" void vtkQuaternionInterpolator_destructor (vtkNew < vtkQuaternionInterpolator > sself) ; -extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkNew < vtkQuaternionInterpolator > sself) ; -extern "C" vtkNew < vtkRungeKutta2 > vtkRungeKutta2_new () ; -extern "C" void vtkRungeKutta2_destructor (vtkNew < vtkRungeKutta2 > sself) ; -extern "C" void * vtkRungeKutta2_get_ptr (vtkNew < vtkRungeKutta2 > sself) ; -extern "C" vtkNew < vtkRungeKutta4 > vtkRungeKutta4_new () ; -extern "C" void vtkRungeKutta4_destructor (vtkNew < vtkRungeKutta4 > sself) ; -extern "C" void * vtkRungeKutta4_get_ptr (vtkNew < vtkRungeKutta4 > sself) ; -extern "C" vtkNew < vtkRungeKutta45 > vtkRungeKutta45_new () ; -extern "C" void vtkRungeKutta45_destructor (vtkNew < vtkRungeKutta45 > sself) ; -extern "C" void * vtkRungeKutta45_get_ptr (vtkNew < vtkRungeKutta45 > sself) ; +extern "C" vtkAmoebaMinimizer * vtkAmoebaMinimizer_new () ; +extern "C" void vtkAmoebaMinimizer_destructor (vtkAmoebaMinimizer * sself) ; +extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkAmoebaMinimizer* sself, const char* name, double value); +extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkAmoebaMinimizer* sself, const char* name, double scale); +extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkAmoebaMinimizer* sself, const char* name); +extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkAmoebaMinimizer* sself, const char* name); +extern "C" const char* vtk_amoeba_minimizer_get_parameter_name(vtkAmoebaMinimizer* sself, int i); +extern "C" int vtk_amoeba_minimizer_get_number_of_parameters(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_initialize(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_minimize(vtkAmoebaMinimizer* sself); +extern "C" int vtk_amoeba_minimizer_iterate(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_function_value(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_function_value(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_contraction_ratio(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_min_value(vtkAmoebaMinimizer* sself); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_max_value(vtkAmoebaMinimizer* sself); +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_expansion_ratio(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_min_value(vtkAmoebaMinimizer* sself); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_max_value(vtkAmoebaMinimizer* sself); +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_tolerance(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_tolerance(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_parameter_tolerance(vtkAmoebaMinimizer* sself, double _arg); +extern "C" double vtk_amoeba_minimizer_get_parameter_tolerance(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_set_max_iterations(vtkAmoebaMinimizer* sself, int _arg); +extern "C" int vtk_amoeba_minimizer_get_max_iterations(vtkAmoebaMinimizer* sself); +extern "C" int vtk_amoeba_minimizer_get_iterations(vtkAmoebaMinimizer* sself); +extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkAmoebaMinimizer* sself); +extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkAmoebaMinimizer* sself); +extern "C" vtkFFT * vtkFFT_new () ; +extern "C" void vtkFFT_destructor (vtkFFT * sself) ; +extern "C" double vtk_fft_hanning_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" double vtk_fft_bartlett_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" double vtk_fft_sine_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" double vtk_fft_blackman_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" double vtk_fft_rectangular_generator(vtkFFT* sself, const size_t x, const size_t size); +extern "C" vtkMatrix3x3 * vtkMatrix3x3_new () ; +extern "C" void vtkMatrix3x3_destructor (vtkMatrix3x3 * sself) ; +extern "C" void vtk_matrix_3_x_3_zero(vtkMatrix3x3* sself); +extern "C" void vtk_matrix_3_x_3_identity(vtkMatrix3x3* sself); +extern "C" double vtk_matrix_3_x_3_determinant(vtkMatrix3x3* sself); +extern "C" void vtk_matrix_3_x_3_set_element(vtkMatrix3x3* sself, int i, int j, double value); +extern "C" double vtk_matrix_3_x_3_get_element(vtkMatrix3x3* sself, int i, int j); +extern "C" bool vtk_matrix_3_x_3_is_identity(vtkMatrix3x3* sself); +extern "C" vtkMatrix4x4 * vtkMatrix4x4_new () ; +extern "C" void vtkMatrix4x4_destructor (vtkMatrix4x4 * sself) ; +extern "C" void vtk_matrix_4_x_4_zero(vtkMatrix4x4* sself); +extern "C" void vtk_matrix_4_x_4_identity(vtkMatrix4x4* sself); +extern "C" bool vtk_matrix_4_x_4_is_identity(vtkMatrix4x4* sself); +extern "C" double vtk_matrix_4_x_4_determinant(vtkMatrix4x4* sself); +extern "C" void vtk_matrix_4_x_4_set_element(vtkMatrix4x4* sself, int i, int j, double value); +extern "C" double vtk_matrix_4_x_4_get_element(vtkMatrix4x4* sself, int i, int j); +extern "C" vtkPolynomialSolversUnivariate * vtkPolynomialSolversUnivariate_new () ; +extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkPolynomialSolversUnivariate * sself) ; +extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkPolynomialSolversUnivariate* sself, double tol); +extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkPolynomialSolversUnivariate* sself); +extern "C" vtkQuaternionInterpolator * vtkQuaternionInterpolator_new () ; +extern "C" void vtkQuaternionInterpolator_destructor (vtkQuaternionInterpolator * sself) ; +extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkQuaternionInterpolator* sself); +extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkQuaternionInterpolator* sself); +extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_initialize(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_remove_quaternion(vtkQuaternionInterpolator* sself, double t); +extern "C" int vtk_quaternion_interpolator_get_search_method(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_set_search_method(vtkQuaternionInterpolator* sself, int type); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type(vtkQuaternionInterpolator* sself, int _arg); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_min_value(vtkQuaternionInterpolator* sself); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_max_value(vtkQuaternionInterpolator* sself); +extern "C" int vtk_quaternion_interpolator_get_interpolation_type(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtkQuaternionInterpolator* sself); +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkQuaternionInterpolator* sself); +extern "C" vtkRungeKutta2 * vtkRungeKutta2_new () ; +extern "C" void vtkRungeKutta2_destructor (vtkRungeKutta2 * sself) ; +extern "C" vtkRungeKutta4 * vtkRungeKutta4_new () ; +extern "C" void vtkRungeKutta4_destructor (vtkRungeKutta4 * sself) ; +extern "C" vtkRungeKutta45 * vtkRungeKutta45_new () ; +extern "C" void vtkRungeKutta45_destructor (vtkRungeKutta45 * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h index 4b57245..558db61 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_misc.h @@ -12,18 +12,81 @@ #include // Declare exported functions -extern "C" vtkNew < vtkContourValues > vtkContourValues_new () ; -extern "C" void vtkContourValues_destructor (vtkNew < vtkContourValues > sself) ; -extern "C" void * vtkContourValues_get_ptr (vtkNew < vtkContourValues > sself) ; -extern "C" vtkNew < vtkExprTkFunctionParser > vtkExprTkFunctionParser_new () ; -extern "C" void vtkExprTkFunctionParser_destructor (vtkNew < vtkExprTkFunctionParser > sself) ; -extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkNew < vtkExprTkFunctionParser > sself) ; -extern "C" vtkNew < vtkFunctionParser > vtkFunctionParser_new () ; -extern "C" void vtkFunctionParser_destructor (vtkNew < vtkFunctionParser > sself) ; -extern "C" void * vtkFunctionParser_get_ptr (vtkNew < vtkFunctionParser > sself) ; -extern "C" vtkNew < vtkHeap > vtkHeap_new () ; -extern "C" void vtkHeap_destructor (vtkNew < vtkHeap > sself) ; -extern "C" void * vtkHeap_get_ptr (vtkNew < vtkHeap > sself) ; -extern "C" vtkNew < vtkResourceFileLocator > vtkResourceFileLocator_new () ; -extern "C" void vtkResourceFileLocator_destructor (vtkNew < vtkResourceFileLocator > sself) ; -extern "C" void * vtkResourceFileLocator_get_ptr (vtkNew < vtkResourceFileLocator > sself) ; +extern "C" vtkContourValues * vtkContourValues_new () ; +extern "C" void vtkContourValues_destructor (vtkContourValues * sself) ; +extern "C" void vtk_contour_values_set_value(vtkContourValues* sself, int i, double value); +extern "C" double vtk_contour_values_get_value(vtkContourValues* sself, int i); +extern "C" void vtk_contour_values_set_number_of_contours(vtkContourValues* sself, const int number); +extern "C" int vtk_contour_values_get_number_of_contours(vtkContourValues* sself); +extern "C" void vtk_contour_values_generate_values(vtkContourValues* sself, int numContours, double rangeStart, double rangeEnd); +extern "C" vtkExprTkFunctionParser * vtkExprTkFunctionParser_new () ; +extern "C" void vtkExprTkFunctionParser_destructor (vtkExprTkFunctionParser * sself) ; +extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_set_function(vtkExprTkFunctionParser* sself, const char* function); +extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkExprTkFunctionParser* sself); +extern "C" int vtk_expr_tk_function_parser_is_scalar_result(vtkExprTkFunctionParser* sself); +extern "C" int vtk_expr_tk_function_parser_is_vector_result(vtkExprTkFunctionParser* sself); +extern "C" double vtk_expr_tk_function_parser_get_scalar_result(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName, double value); +extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName); +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName, double xValue, double yValue, double zValue); +extern "C" int vtk_expr_tk_function_parser_get_number_of_scalar_variables(vtkExprTkFunctionParser* sself); +extern "C" int vtk_expr_tk_function_parser_get_scalar_variable_index(vtkExprTkFunctionParser* sself, const char*& name); +extern "C" int vtk_expr_tk_function_parser_get_number_of_vector_variables(vtkExprTkFunctionParser* sself); +extern "C" int vtk_expr_tk_function_parser_get_vector_variable_index(vtkExprTkFunctionParser* sself, const char*& name); +extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkExprTkFunctionParser* sself, int i); +extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkExprTkFunctionParser* sself, int i); +extern "C" void vtk_expr_tk_function_parser_remove_all_variables(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_remove_scalar_variables(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_remove_vector_variables(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_set_replace_invalid_values(vtkExprTkFunctionParser* sself, int _arg); +extern "C" int vtk_expr_tk_function_parser_get_replace_invalid_values(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_on(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_off(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_set_replacement_value(vtkExprTkFunctionParser* sself, double _arg); +extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkExprTkFunctionParser* sself); +extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkExprTkFunctionParser* sself); +extern "C" vtkFunctionParser * vtkFunctionParser_new () ; +extern "C" void vtkFunctionParser_destructor (vtkFunctionParser * sself) ; +extern "C" unsigned long vtk_function_parser_get_m_time(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_set_function(vtkFunctionParser* sself, const char* function); +extern "C" int vtk_function_parser_is_scalar_result(vtkFunctionParser* sself); +extern "C" int vtk_function_parser_is_vector_result(vtkFunctionParser* sself); +extern "C" double vtk_function_parser_get_scalar_result(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkFunctionParser* sself, const char* variableName, double value); +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkFunctionParser* sself, const char* variableName); +extern "C" void vtk_function_parser_set_vector_variable_value(vtkFunctionParser* sself, const char* variableName, double xValue, double yValue, double zValue); +extern "C" int vtk_function_parser_get_number_of_scalar_variables(vtkFunctionParser* sself); +extern "C" int vtk_function_parser_get_scalar_variable_index(vtkFunctionParser* sself, const char* name); +extern "C" int vtk_function_parser_get_number_of_vector_variables(vtkFunctionParser* sself); +extern "C" int vtk_function_parser_get_vector_variable_index(vtkFunctionParser* sself, const char* name); +extern "C" const char* vtk_function_parser_get_scalar_variable_name(vtkFunctionParser* sself, int i); +extern "C" const char* vtk_function_parser_get_vector_variable_name(vtkFunctionParser* sself, int i); +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkFunctionParser* sself, int i); +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkFunctionParser* sself, int i); +extern "C" void vtk_function_parser_remove_all_variables(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_remove_scalar_variables(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_remove_vector_variables(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_set_replace_invalid_values(vtkFunctionParser* sself, int _arg); +extern "C" int vtk_function_parser_get_replace_invalid_values(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_replace_invalid_values_on(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_replace_invalid_values_off(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_set_replacement_value(vtkFunctionParser* sself, double _arg); +extern "C" double vtk_function_parser_get_replacement_value(vtkFunctionParser* sself); +extern "C" void vtk_function_parser_invalidate_function(vtkFunctionParser* sself); +extern "C" vtkHeap * vtkHeap_new () ; +extern "C" void vtkHeap_destructor (vtkHeap * sself) ; +extern "C" void* vtk_heap_allocate_memory(vtkHeap* sself, size_t n); +extern "C" void vtk_heap_set_block_size(vtkHeap* sself, size_t p0); +extern "C" size_t vtk_heap_get_block_size(vtkHeap* sself); +extern "C" int vtk_heap_get_number_of_blocks(vtkHeap* sself); +extern "C" int vtk_heap_get_number_of_allocations(vtkHeap* sself); +extern "C" void vtk_heap_reset(vtkHeap* sself); +extern "C" vtkResourceFileLocator * vtkResourceFileLocator_new () ; +extern "C" void vtkResourceFileLocator_destructor (vtkResourceFileLocator * sself) ; +extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkResourceFileLocator* sself, bool p0); +extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkResourceFileLocator* sself); +extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkResourceFileLocator* sself); +extern "C" void vtk_resource_file_locator_print_debug_information_off(vtkResourceFileLocator* sself); +extern "C" void vtk_resource_file_locator_set_log_verbosity(vtkResourceFileLocator* sself, int _arg); +extern "C" int vtk_resource_file_locator_get_log_verbosity(vtkResourceFileLocator* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h index 650c5b9..60894a5 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_system.h @@ -15,24 +15,68 @@ #include // Declare exported functions -extern "C" vtkNew < vtkClientSocket > vtkClientSocket_new () ; -extern "C" void vtkClientSocket_destructor (vtkNew < vtkClientSocket > sself) ; -extern "C" void * vtkClientSocket_get_ptr (vtkNew < vtkClientSocket > sself) ; -extern "C" vtkNew < vtkDirectory > vtkDirectory_new () ; -extern "C" void vtkDirectory_destructor (vtkNew < vtkDirectory > sself) ; -extern "C" void * vtkDirectory_get_ptr (vtkNew < vtkDirectory > sself) ; -extern "C" vtkNew < vtkExecutableRunner > vtkExecutableRunner_new () ; -extern "C" void vtkExecutableRunner_destructor (vtkNew < vtkExecutableRunner > sself) ; -extern "C" void * vtkExecutableRunner_get_ptr (vtkNew < vtkExecutableRunner > sself) ; -extern "C" vtkNew < vtkServerSocket > vtkServerSocket_new () ; -extern "C" void vtkServerSocket_destructor (vtkNew < vtkServerSocket > sself) ; -extern "C" void * vtkServerSocket_get_ptr (vtkNew < vtkServerSocket > sself) ; -extern "C" vtkNew < vtkSocketCollection > vtkSocketCollection_new () ; -extern "C" void vtkSocketCollection_destructor (vtkNew < vtkSocketCollection > sself) ; -extern "C" void * vtkSocketCollection_get_ptr (vtkNew < vtkSocketCollection > sself) ; -extern "C" vtkNew < vtkThreadMessager > vtkThreadMessager_new () ; -extern "C" void vtkThreadMessager_destructor (vtkNew < vtkThreadMessager > sself) ; -extern "C" void * vtkThreadMessager_get_ptr (vtkNew < vtkThreadMessager > sself) ; -extern "C" vtkNew < vtkTimerLog > vtkTimerLog_new () ; -extern "C" void vtkTimerLog_destructor (vtkNew < vtkTimerLog > sself) ; -extern "C" void * vtkTimerLog_get_ptr (vtkNew < vtkTimerLog > sself) ; +extern "C" vtkClientSocket * vtkClientSocket_new () ; +extern "C" void vtkClientSocket_destructor (vtkClientSocket * sself) ; +extern "C" int vtk_client_socket_connect_to_server(vtkClientSocket* sself, const char* hostname, int port); +extern "C" bool vtk_client_socket_get_connecting_side(vtkClientSocket* sself); +extern "C" vtkDirectory * vtkDirectory_new () ; +extern "C" void vtkDirectory_destructor (vtkDirectory * sself) ; +extern "C" int vtk_directory_open(vtkDirectory* sself, const char* dir); +extern "C" long long vtk_directory_get_number_of_files(vtkDirectory* sself); +extern "C" const char* vtk_directory_get_file(vtkDirectory* sself, long long index); +extern "C" int vtk_directory_file_is_directory(vtkDirectory* sself, const char* name); +extern "C" int vtk_directory_make_directory(vtkDirectory* sself, const char* dir); +extern "C" int vtk_directory_delete_directory(vtkDirectory* sself, const char* dir); +extern "C" int vtk_directory_rename(vtkDirectory* sself, const char* oldname, const char* newname); +extern "C" vtkExecutableRunner * vtkExecutableRunner_new () ; +extern "C" void vtkExecutableRunner_destructor (vtkExecutableRunner * sself) ; +extern "C" void vtk_executable_runner_execute(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_set_timeout(vtkExecutableRunner* sself, double _arg); +extern "C" double vtk_executable_runner_get_timeout(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_set_right_trim_result(vtkExecutableRunner* sself, bool _arg); +extern "C" bool vtk_executable_runner_get_right_trim_result(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_right_trim_result_on(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_right_trim_result_off(vtkExecutableRunner* sself); +extern "C" const char* vtk_executable_runner_get_command(vtkExecutableRunner* sself); +extern "C" void vtk_executable_runner_set_command(vtkExecutableRunner* sself, const char* arg); +extern "C" const char* vtk_executable_runner_get_std_out(vtkExecutableRunner* sself); +extern "C" const char* vtk_executable_runner_get_std_err(vtkExecutableRunner* sself); +extern "C" int vtk_executable_runner_get_return_value(vtkExecutableRunner* sself); +extern "C" vtkServerSocket * vtkServerSocket_new () ; +extern "C" void vtkServerSocket_destructor (vtkServerSocket * sself) ; +extern "C" int vtk_server_socket_create_server(vtkServerSocket* sself, int port); +extern "C" int vtk_server_socket_get_server_port(vtkServerSocket* sself); +extern "C" vtkSocketCollection * vtkSocketCollection_new () ; +extern "C" void vtkSocketCollection_destructor (vtkSocketCollection * sself) ; +extern "C" int vtk_socket_collection_select_sockets(vtkSocketCollection* sself, unsigned long msec); +extern "C" vtkThreadMessager * vtkThreadMessager_new () ; +extern "C" void vtkThreadMessager_destructor (vtkThreadMessager * sself) ; +extern "C" void vtk_thread_messager_wait_for_message(vtkThreadMessager* sself); +extern "C" void vtk_thread_messager_send_wake_message(vtkThreadMessager* sself); +extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkThreadMessager* sself); +extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkThreadMessager* sself); +extern "C" void vtk_thread_messager_wait_for_receiver(vtkThreadMessager* sself); +extern "C" vtkTimerLog * vtkTimerLog_new () ; +extern "C" void vtkTimerLog_destructor (vtkTimerLog * sself) ; +extern "C" void vtk_timer_log_set_logging(vtkTimerLog* sself, int v); +extern "C" int vtk_timer_log_get_logging(vtkTimerLog* sself); +extern "C" void vtk_timer_log_logging_on(vtkTimerLog* sself); +extern "C" void vtk_timer_log_logging_off(vtkTimerLog* sself); +extern "C" void vtk_timer_log_set_max_entries(vtkTimerLog* sself, int a); +extern "C" int vtk_timer_log_get_max_entries(vtkTimerLog* sself); +extern "C" void vtk_timer_log_dump_log(vtkTimerLog* sself, const char* filename); +extern "C" void vtk_timer_log_mark_start_event(vtkTimerLog* sself, const char* EventString); +extern "C" void vtk_timer_log_mark_end_event(vtkTimerLog* sself, const char* EventString); +extern "C" void vtk_timer_log_insert_timed_event(vtkTimerLog* sself, const char* EventString, double time, int cpuTicks); +extern "C" int vtk_timer_log_get_number_of_events(vtkTimerLog* sself); +extern "C" int vtk_timer_log_get_event_indent(vtkTimerLog* sself, int i); +extern "C" double vtk_timer_log_get_event_wall_time(vtkTimerLog* sself, int i); +extern "C" const char* vtk_timer_log_get_event_string(vtkTimerLog* sself, int i); +extern "C" void vtk_timer_log_mark_event(vtkTimerLog* sself, const char* EventString); +extern "C" void vtk_timer_log_reset_log(vtkTimerLog* sself); +extern "C" void vtk_timer_log_cleanup_log(vtkTimerLog* sself); +extern "C" double vtk_timer_log_get_universal_time(vtkTimerLog* sself); +extern "C" double vtk_timer_log_get_cpu_time(vtkTimerLog* sself); +extern "C" void vtk_timer_log_start_timer(vtkTimerLog* sself); +extern "C" void vtk_timer_log_stop_timer(vtkTimerLog* sself); +extern "C" double vtk_timer_log_get_elapsed_time(vtkTimerLog* sself); diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h b/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h index 9fd156d..67b1786 100644 --- a/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h +++ b/vtk-rs-9.1/libvtkrs/include/vtk_common_transforms.h @@ -24,39 +24,111 @@ #include // Declare exported functions -extern "C" vtkNew < vtkCylindricalTransform > vtkCylindricalTransform_new () ; -extern "C" void vtkCylindricalTransform_destructor (vtkNew < vtkCylindricalTransform > sself) ; -extern "C" void * vtkCylindricalTransform_get_ptr (vtkNew < vtkCylindricalTransform > sself) ; -extern "C" vtkNew < vtkGeneralTransform > vtkGeneralTransform_new () ; -extern "C" void vtkGeneralTransform_destructor (vtkNew < vtkGeneralTransform > sself) ; -extern "C" void * vtkGeneralTransform_get_ptr (vtkNew < vtkGeneralTransform > sself) ; -extern "C" vtkNew < vtkIdentityTransform > vtkIdentityTransform_new () ; -extern "C" void vtkIdentityTransform_destructor (vtkNew < vtkIdentityTransform > sself) ; -extern "C" void * vtkIdentityTransform_get_ptr (vtkNew < vtkIdentityTransform > sself) ; -extern "C" vtkNew < vtkLandmarkTransform > vtkLandmarkTransform_new () ; -extern "C" void vtkLandmarkTransform_destructor (vtkNew < vtkLandmarkTransform > sself) ; -extern "C" void * vtkLandmarkTransform_get_ptr (vtkNew < vtkLandmarkTransform > sself) ; -extern "C" vtkNew < vtkMatrixToHomogeneousTransform > vtkMatrixToHomogeneousTransform_new () ; -extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkNew < vtkMatrixToHomogeneousTransform > sself) ; -extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkNew < vtkMatrixToHomogeneousTransform > sself) ; -extern "C" vtkNew < vtkMatrixToLinearTransform > vtkMatrixToLinearTransform_new () ; -extern "C" void vtkMatrixToLinearTransform_destructor (vtkNew < vtkMatrixToLinearTransform > sself) ; -extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkNew < vtkMatrixToLinearTransform > sself) ; -extern "C" vtkNew < vtkPerspectiveTransform > vtkPerspectiveTransform_new () ; -extern "C" void vtkPerspectiveTransform_destructor (vtkNew < vtkPerspectiveTransform > sself) ; -extern "C" void * vtkPerspectiveTransform_get_ptr (vtkNew < vtkPerspectiveTransform > sself) ; -extern "C" vtkNew < vtkSphericalTransform > vtkSphericalTransform_new () ; -extern "C" void vtkSphericalTransform_destructor (vtkNew < vtkSphericalTransform > sself) ; -extern "C" void * vtkSphericalTransform_get_ptr (vtkNew < vtkSphericalTransform > sself) ; -extern "C" vtkNew < vtkThinPlateSplineTransform > vtkThinPlateSplineTransform_new () ; -extern "C" void vtkThinPlateSplineTransform_destructor (vtkNew < vtkThinPlateSplineTransform > sself) ; -extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkNew < vtkThinPlateSplineTransform > sself) ; -extern "C" vtkNew < vtkTransform > vtkTransform_new () ; -extern "C" void vtkTransform_destructor (vtkNew < vtkTransform > sself) ; -extern "C" void * vtkTransform_get_ptr (vtkNew < vtkTransform > sself) ; -extern "C" vtkNew < vtkTransform2D > vtkTransform2D_new () ; -extern "C" void vtkTransform2D_destructor (vtkNew < vtkTransform2D > sself) ; -extern "C" void * vtkTransform2D_get_ptr (vtkNew < vtkTransform2D > sself) ; -extern "C" vtkNew < vtkTransformCollection > vtkTransformCollection_new () ; -extern "C" void vtkTransformCollection_destructor (vtkNew < vtkTransformCollection > sself) ; -extern "C" void * vtkTransformCollection_get_ptr (vtkNew < vtkTransformCollection > sself) ; +extern "C" vtkCylindricalTransform * vtkCylindricalTransform_new () ; +extern "C" void vtkCylindricalTransform_destructor (vtkCylindricalTransform * sself) ; +extern "C" vtkGeneralTransform * vtkGeneralTransform_new () ; +extern "C" void vtkGeneralTransform_destructor (vtkGeneralTransform * sself) ; +extern "C" void vtk_general_transform_identity(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_inverse(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_translate(vtkGeneralTransform* sself, double x, double y, double z); +extern "C" void vtk_general_transform_rotate_wxyz(vtkGeneralTransform* sself, double angle, double x, double y, double z); +extern "C" void vtk_general_transform_rotate_x(vtkGeneralTransform* sself, double angle); +extern "C" void vtk_general_transform_rotate_y(vtkGeneralTransform* sself, double angle); +extern "C" void vtk_general_transform_rotate_z(vtkGeneralTransform* sself, double angle); +extern "C" void vtk_general_transform_scale(vtkGeneralTransform* sself, double x, double y, double z); +extern "C" void vtk_general_transform_pre_multiply(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_post_multiply(vtkGeneralTransform* sself); +extern "C" int vtk_general_transform_get_number_of_concatenated_transforms(vtkGeneralTransform* sself); +extern "C" int vtk_general_transform_get_inverse_flag(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_push(vtkGeneralTransform* sself); +extern "C" void vtk_general_transform_pop(vtkGeneralTransform* sself); +extern "C" unsigned long vtk_general_transform_get_m_time(vtkGeneralTransform* sself); +extern "C" vtkIdentityTransform * vtkIdentityTransform_new () ; +extern "C" void vtkIdentityTransform_destructor (vtkIdentityTransform * sself) ; +extern "C" void vtk_identity_transform_inverse(vtkIdentityTransform* sself); +extern "C" vtkLandmarkTransform * vtkLandmarkTransform_new () ; +extern "C" void vtkLandmarkTransform_destructor (vtkLandmarkTransform * sself) ; +extern "C" void vtk_landmark_transform_set_mode(vtkLandmarkTransform* sself, int _arg); +extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkLandmarkTransform* sself); +extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkLandmarkTransform* sself); +extern "C" void vtk_landmark_transform_set_mode_to_affine(vtkLandmarkTransform* sself); +extern "C" int vtk_landmark_transform_get_mode(vtkLandmarkTransform* sself); +extern "C" const char* vtk_landmark_transform_get_mode_as_string(vtkLandmarkTransform* sself); +extern "C" void vtk_landmark_transform_inverse(vtkLandmarkTransform* sself); +extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkLandmarkTransform* sself); +extern "C" vtkMatrixToHomogeneousTransform * vtkMatrixToHomogeneousTransform_new () ; +extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkMatrixToHomogeneousTransform * sself) ; +extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkMatrixToHomogeneousTransform* sself); +extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkMatrixToHomogeneousTransform* sself); +extern "C" vtkMatrixToLinearTransform * vtkMatrixToLinearTransform_new () ; +extern "C" void vtkMatrixToLinearTransform_destructor (vtkMatrixToLinearTransform * sself) ; +extern "C" void vtk_matrix_to_linear_transform_inverse(vtkMatrixToLinearTransform* sself); +extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkMatrixToLinearTransform* sself); +extern "C" vtkPerspectiveTransform * vtkPerspectiveTransform_new () ; +extern "C" void vtkPerspectiveTransform_destructor (vtkPerspectiveTransform * sself) ; +extern "C" void vtk_perspective_transform_identity(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_inverse(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_adjust_viewport(vtkPerspectiveTransform* sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax); +extern "C" void vtk_perspective_transform_adjust_z_buffer(vtkPerspectiveTransform* sself, double oldNearZ, double oldFarZ, double newNearZ, double newFarZ); +extern "C" void vtk_perspective_transform_ortho(vtkPerspectiveTransform* sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar); +extern "C" void vtk_perspective_transform_frustum(vtkPerspectiveTransform* sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar); +extern "C" void vtk_perspective_transform_perspective(vtkPerspectiveTransform* sself, double angle, double aspect, double znear, double zfar); +extern "C" void vtk_perspective_transform_shear(vtkPerspectiveTransform* sself, double dxdz, double dydz, double zplane); +extern "C" void vtk_perspective_transform_stereo(vtkPerspectiveTransform* sself, double angle, double focaldistance); +extern "C" void vtk_perspective_transform_setup_camera(vtkPerspectiveTransform* sself, double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2); +extern "C" void vtk_perspective_transform_translate(vtkPerspectiveTransform* sself, double x, double y, double z); +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkPerspectiveTransform* sself, double angle, double x, double y, double z); +extern "C" void vtk_perspective_transform_rotate_x(vtkPerspectiveTransform* sself, double angle); +extern "C" void vtk_perspective_transform_rotate_y(vtkPerspectiveTransform* sself, double angle); +extern "C" void vtk_perspective_transform_rotate_z(vtkPerspectiveTransform* sself, double angle); +extern "C" void vtk_perspective_transform_scale(vtkPerspectiveTransform* sself, double x, double y, double z); +extern "C" void vtk_perspective_transform_pre_multiply(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_post_multiply(vtkPerspectiveTransform* sself); +extern "C" int vtk_perspective_transform_get_number_of_concatenated_transforms(vtkPerspectiveTransform* sself); +extern "C" int vtk_perspective_transform_get_inverse_flag(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_push(vtkPerspectiveTransform* sself); +extern "C" void vtk_perspective_transform_pop(vtkPerspectiveTransform* sself); +extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkPerspectiveTransform* sself); +extern "C" vtkSphericalTransform * vtkSphericalTransform_new () ; +extern "C" void vtkSphericalTransform_destructor (vtkSphericalTransform * sself) ; +extern "C" vtkThinPlateSplineTransform * vtkThinPlateSplineTransform_new () ; +extern "C" void vtkThinPlateSplineTransform_destructor (vtkThinPlateSplineTransform * sself) ; +extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkThinPlateSplineTransform* sself, double _arg); +extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkThinPlateSplineTransform* sself, int basis); +extern "C" int vtk_thin_plate_spline_transform_get_basis(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(vtkThinPlateSplineTransform* sself); +extern "C" const char* vtk_thin_plate_spline_transform_get_basis_as_string(vtkThinPlateSplineTransform* sself); +extern "C" unsigned long vtk_thin_plate_spline_transform_get_m_time(vtkThinPlateSplineTransform* sself); +extern "C" bool vtk_thin_plate_spline_transform_get_regularize_bulk_transform(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_set_regularize_bulk_transform(vtkThinPlateSplineTransform* sself, bool _arg); +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtkThinPlateSplineTransform* sself); +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkThinPlateSplineTransform* sself); +extern "C" vtkTransform * vtkTransform_new () ; +extern "C" void vtkTransform_destructor (vtkTransform * sself) ; +extern "C" void vtk_transform_identity(vtkTransform* sself); +extern "C" void vtk_transform_inverse(vtkTransform* sself); +extern "C" void vtk_transform_translate(vtkTransform* sself, double x, double y, double z); +extern "C" void vtk_transform_rotate_wxyz(vtkTransform* sself, double angle, double x, double y, double z); +extern "C" void vtk_transform_rotate_x(vtkTransform* sself, double angle); +extern "C" void vtk_transform_rotate_y(vtkTransform* sself, double angle); +extern "C" void vtk_transform_rotate_z(vtkTransform* sself, double angle); +extern "C" void vtk_transform_scale(vtkTransform* sself, double x, double y, double z); +extern "C" void vtk_transform_pre_multiply(vtkTransform* sself); +extern "C" void vtk_transform_post_multiply(vtkTransform* sself); +extern "C" int vtk_transform_get_number_of_concatenated_transforms(vtkTransform* sself); +extern "C" int vtk_transform_get_inverse_flag(vtkTransform* sself); +extern "C" void vtk_transform_push(vtkTransform* sself); +extern "C" void vtk_transform_pop(vtkTransform* sself); +extern "C" unsigned long vtk_transform_get_m_time(vtkTransform* sself); +extern "C" vtkTransform2D * vtkTransform2D_new () ; +extern "C" void vtkTransform2D_destructor (vtkTransform2D * sself) ; +extern "C" void vtk_transform_2_d_identity(vtkTransform2D* sself); +extern "C" void vtk_transform_2_d_inverse(vtkTransform2D* sself); +extern "C" void vtk_transform_2_d_translate(vtkTransform2D* sself, double x, double y); +extern "C" void vtk_transform_2_d_rotate(vtkTransform2D* sself, double angle); +extern "C" void vtk_transform_2_d_scale(vtkTransform2D* sself, double x, double y); +extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkTransform2D* sself); +extern "C" vtkTransformCollection * vtkTransformCollection_new () ; +extern "C" void vtkTransformCollection_destructor (vtkTransformCollection * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h b/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h new file mode 100644 index 0000000..7e04023 --- /dev/null +++ b/vtk-rs-9.1/libvtkrs/include/vtk_filters_sources.h @@ -0,0 +1,799 @@ +// Default include in all modules +#include +#include + +// Include objects of this module +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Declare exported functions +extern "C" vtkArcSource * vtkArcSource_new () ; +extern "C" void vtkArcSource_destructor (vtkArcSource * sself) ; +extern "C" void vtk_arc_source_set_point_1(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_point_2(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_center(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_normal(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_polar_vector(vtkArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_arc_source_set_angle(vtkArcSource* sself, double _arg); +extern "C" double vtk_arc_source_get_angle_min_value(vtkArcSource* sself); +extern "C" double vtk_arc_source_get_angle_max_value(vtkArcSource* sself); +extern "C" double vtk_arc_source_get_angle(vtkArcSource* sself); +extern "C" void vtk_arc_source_set_resolution(vtkArcSource* sself, int _arg); +extern "C" int vtk_arc_source_get_resolution_min_value(vtkArcSource* sself); +extern "C" int vtk_arc_source_get_resolution_max_value(vtkArcSource* sself); +extern "C" int vtk_arc_source_get_resolution(vtkArcSource* sself); +extern "C" void vtk_arc_source_set_negative(vtkArcSource* sself, bool _arg); +extern "C" bool vtk_arc_source_get_negative(vtkArcSource* sself); +extern "C" void vtk_arc_source_negative_on(vtkArcSource* sself); +extern "C" void vtk_arc_source_negative_off(vtkArcSource* sself); +extern "C" void vtk_arc_source_set_use_normal_and_angle(vtkArcSource* sself, bool _arg); +extern "C" bool vtk_arc_source_get_use_normal_and_angle(vtkArcSource* sself); +extern "C" void vtk_arc_source_use_normal_and_angle_on(vtkArcSource* sself); +extern "C" void vtk_arc_source_use_normal_and_angle_off(vtkArcSource* sself); +extern "C" void vtk_arc_source_set_output_points_precision(vtkArcSource* sself, int _arg); +extern "C" int vtk_arc_source_get_output_points_precision(vtkArcSource* sself); +extern "C" vtkArrowSource * vtkArrowSource_new () ; +extern "C" void vtkArrowSource_destructor (vtkArrowSource * sself) ; +extern "C" void vtk_arrow_source_set_tip_length(vtkArrowSource* sself, double _arg); +extern "C" double vtk_arrow_source_get_tip_length_min_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_tip_length_max_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_tip_length(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_tip_radius(vtkArrowSource* sself, double _arg); +extern "C" double vtk_arrow_source_get_tip_radius_min_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_tip_radius_max_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_tip_radius(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_tip_resolution(vtkArrowSource* sself, int _arg); +extern "C" int vtk_arrow_source_get_tip_resolution_min_value(vtkArrowSource* sself); +extern "C" int vtk_arrow_source_get_tip_resolution_max_value(vtkArrowSource* sself); +extern "C" int vtk_arrow_source_get_tip_resolution(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_shaft_radius(vtkArrowSource* sself, double _arg); +extern "C" double vtk_arrow_source_get_shaft_radius_min_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_shaft_radius_max_value(vtkArrowSource* sself); +extern "C" double vtk_arrow_source_get_shaft_radius(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_shaft_resolution(vtkArrowSource* sself, int _arg); +extern "C" int vtk_arrow_source_get_shaft_resolution_min_value(vtkArrowSource* sself); +extern "C" int vtk_arrow_source_get_shaft_resolution_max_value(vtkArrowSource* sself); +extern "C" int vtk_arrow_source_get_shaft_resolution(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_invert_on(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_invert_off(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_invert(vtkArrowSource* sself, bool _arg); +extern "C" bool vtk_arrow_source_get_invert(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_arrow_origin_to_default(vtkArrowSource* sself); +extern "C" void vtk_arrow_source_set_arrow_origin_to_center(vtkArrowSource* sself); +extern "C" vtkCapsuleSource * vtkCapsuleSource_new () ; +extern "C" void vtkCapsuleSource_destructor (vtkCapsuleSource * sself) ; +extern "C" void vtk_capsule_source_set_radius(vtkCapsuleSource* sself, double _arg); +extern "C" double vtk_capsule_source_get_radius_min_value(vtkCapsuleSource* sself); +extern "C" double vtk_capsule_source_get_radius_max_value(vtkCapsuleSource* sself); +extern "C" double vtk_capsule_source_get_radius(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_center(vtkCapsuleSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_capsule_source_set_cylinder_length(vtkCapsuleSource* sself, double _arg); +extern "C" double vtk_capsule_source_get_cylinder_length_min_value(vtkCapsuleSource* sself); +extern "C" double vtk_capsule_source_get_cylinder_length_max_value(vtkCapsuleSource* sself); +extern "C" double vtk_capsule_source_get_cylinder_length(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_theta_resolution(vtkCapsuleSource* sself, int _arg); +extern "C" int vtk_capsule_source_get_theta_resolution_min_value(vtkCapsuleSource* sself); +extern "C" int vtk_capsule_source_get_theta_resolution_max_value(vtkCapsuleSource* sself); +extern "C" int vtk_capsule_source_get_theta_resolution(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_phi_resolution(vtkCapsuleSource* sself, int _arg); +extern "C" int vtk_capsule_source_get_phi_resolution_min_value(vtkCapsuleSource* sself); +extern "C" int vtk_capsule_source_get_phi_resolution_max_value(vtkCapsuleSource* sself); +extern "C" int vtk_capsule_source_get_phi_resolution(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_lat_long_tessellation(vtkCapsuleSource* sself, int _arg); +extern "C" int vtk_capsule_source_get_lat_long_tessellation(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_lat_long_tessellation_on(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_lat_long_tessellation_off(vtkCapsuleSource* sself); +extern "C" void vtk_capsule_source_set_output_points_precision(vtkCapsuleSource* sself, int _arg); +extern "C" int vtk_capsule_source_get_output_points_precision(vtkCapsuleSource* sself); +extern "C" vtkCellTypeSource * vtkCellTypeSource_new () ; +extern "C" void vtkCellTypeSource_destructor (vtkCellTypeSource * sself) ; +extern "C" void vtk_cell_type_source_set_cell_type(vtkCellTypeSource* sself, int cellType); +extern "C" int vtk_cell_type_source_get_cell_type(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_set_cell_order(vtkCellTypeSource* sself, int _arg); +extern "C" int vtk_cell_type_source_get_cell_order(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_set_complete_quadratic_simplicial_elements(vtkCellTypeSource* sself, bool _arg); +extern "C" bool vtk_cell_type_source_get_complete_quadratic_simplicial_elements(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_complete_quadratic_simplicial_elements_on(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_complete_quadratic_simplicial_elements_off(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_set_polynomial_field_order(vtkCellTypeSource* sself, int _arg); +extern "C" int vtk_cell_type_source_get_polynomial_field_order_min_value(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_polynomial_field_order_max_value(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_polynomial_field_order(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_cell_dimension(vtkCellTypeSource* sself); +extern "C" void vtk_cell_type_source_set_output_precision(vtkCellTypeSource* sself, int _arg); +extern "C" int vtk_cell_type_source_get_output_precision_min_value(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_output_precision_max_value(vtkCellTypeSource* sself); +extern "C" int vtk_cell_type_source_get_output_precision(vtkCellTypeSource* sself); +extern "C" vtkConeSource * vtkConeSource_new () ; +extern "C" void vtkConeSource_destructor (vtkConeSource * sself) ; +extern "C" void vtk_cone_source_set_height(vtkConeSource* sself, double _arg); +extern "C" double vtk_cone_source_get_height_min_value(vtkConeSource* sself); +extern "C" double vtk_cone_source_get_height_max_value(vtkConeSource* sself); +extern "C" double vtk_cone_source_get_height(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_radius(vtkConeSource* sself, double _arg); +extern "C" double vtk_cone_source_get_radius_min_value(vtkConeSource* sself); +extern "C" double vtk_cone_source_get_radius_max_value(vtkConeSource* sself); +extern "C" double vtk_cone_source_get_radius(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_resolution(vtkConeSource* sself, int _arg); +extern "C" int vtk_cone_source_get_resolution_min_value(vtkConeSource* sself); +extern "C" int vtk_cone_source_get_resolution_max_value(vtkConeSource* sself); +extern "C" int vtk_cone_source_get_resolution(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_center(vtkConeSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cone_source_set_direction(vtkConeSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cone_source_set_angle(vtkConeSource* sself, double angle); +extern "C" double vtk_cone_source_get_angle(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_capping(vtkConeSource* sself, int _arg); +extern "C" int vtk_cone_source_get_capping(vtkConeSource* sself); +extern "C" void vtk_cone_source_capping_on(vtkConeSource* sself); +extern "C" void vtk_cone_source_capping_off(vtkConeSource* sself); +extern "C" void vtk_cone_source_set_output_points_precision(vtkConeSource* sself, int _arg); +extern "C" int vtk_cone_source_get_output_points_precision(vtkConeSource* sself); +extern "C" vtkCubeSource * vtkCubeSource_new () ; +extern "C" void vtkCubeSource_destructor (vtkCubeSource * sself) ; +extern "C" void vtk_cube_source_set_x_length(vtkCubeSource* sself, double _arg); +extern "C" double vtk_cube_source_get_x_length_min_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_x_length_max_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_x_length(vtkCubeSource* sself); +extern "C" void vtk_cube_source_set_y_length(vtkCubeSource* sself, double _arg); +extern "C" double vtk_cube_source_get_y_length_min_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_y_length_max_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_y_length(vtkCubeSource* sself); +extern "C" void vtk_cube_source_set_z_length(vtkCubeSource* sself, double _arg); +extern "C" double vtk_cube_source_get_z_length_min_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_z_length_max_value(vtkCubeSource* sself); +extern "C" double vtk_cube_source_get_z_length(vtkCubeSource* sself); +extern "C" void vtk_cube_source_set_center(vtkCubeSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cube_source_set_bounds(vtkCubeSource* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax); +extern "C" void vtk_cube_source_set_output_points_precision(vtkCubeSource* sself, int _arg); +extern "C" int vtk_cube_source_get_output_points_precision(vtkCubeSource* sself); +extern "C" vtkCylinderSource * vtkCylinderSource_new () ; +extern "C" void vtkCylinderSource_destructor (vtkCylinderSource * sself) ; +extern "C" void vtk_cylinder_source_set_height(vtkCylinderSource* sself, double _arg); +extern "C" double vtk_cylinder_source_get_height_min_value(vtkCylinderSource* sself); +extern "C" double vtk_cylinder_source_get_height_max_value(vtkCylinderSource* sself); +extern "C" double vtk_cylinder_source_get_height(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_set_radius(vtkCylinderSource* sself, double _arg); +extern "C" double vtk_cylinder_source_get_radius_min_value(vtkCylinderSource* sself); +extern "C" double vtk_cylinder_source_get_radius_max_value(vtkCylinderSource* sself); +extern "C" double vtk_cylinder_source_get_radius(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_set_center(vtkCylinderSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_cylinder_source_set_resolution(vtkCylinderSource* sself, int _arg); +extern "C" int vtk_cylinder_source_get_resolution_min_value(vtkCylinderSource* sself); +extern "C" int vtk_cylinder_source_get_resolution_max_value(vtkCylinderSource* sself); +extern "C" int vtk_cylinder_source_get_resolution(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_set_capping(vtkCylinderSource* sself, int _arg); +extern "C" int vtk_cylinder_source_get_capping(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_capping_on(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_capping_off(vtkCylinderSource* sself); +extern "C" void vtk_cylinder_source_set_output_points_precision(vtkCylinderSource* sself, int _arg); +extern "C" int vtk_cylinder_source_get_output_points_precision(vtkCylinderSource* sself); +extern "C" vtkDiagonalMatrixSource * vtkDiagonalMatrixSource_new () ; +extern "C" void vtkDiagonalMatrixSource_destructor (vtkDiagonalMatrixSource * sself) ; +extern "C" int vtk_diagonal_matrix_source_get_array_type(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_array_type(vtkDiagonalMatrixSource* sself, int _arg); +extern "C" long long vtk_diagonal_matrix_source_get_extents(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_extents(vtkDiagonalMatrixSource* sself, long long _arg); +extern "C" double vtk_diagonal_matrix_source_get_diagonal(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_diagonal(vtkDiagonalMatrixSource* sself, double _arg); +extern "C" double vtk_diagonal_matrix_source_get_super_diagonal(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_super_diagonal(vtkDiagonalMatrixSource* sself, double _arg); +extern "C" double vtk_diagonal_matrix_source_get_sub_diagonal(vtkDiagonalMatrixSource* sself); +extern "C" void vtk_diagonal_matrix_source_set_sub_diagonal(vtkDiagonalMatrixSource* sself, double _arg); +extern "C" void vtk_diagonal_matrix_source_set_row_label(vtkDiagonalMatrixSource* sself, const char* _arg); +extern "C" void vtk_diagonal_matrix_source_set_column_label(vtkDiagonalMatrixSource* sself, const char* _arg); +extern "C" vtkDiskSource * vtkDiskSource_new () ; +extern "C" void vtkDiskSource_destructor (vtkDiskSource * sself) ; +extern "C" void vtk_disk_source_set_inner_radius(vtkDiskSource* sself, double _arg); +extern "C" double vtk_disk_source_get_inner_radius_min_value(vtkDiskSource* sself); +extern "C" double vtk_disk_source_get_inner_radius_max_value(vtkDiskSource* sself); +extern "C" double vtk_disk_source_get_inner_radius(vtkDiskSource* sself); +extern "C" void vtk_disk_source_set_outer_radius(vtkDiskSource* sself, double _arg); +extern "C" double vtk_disk_source_get_outer_radius_min_value(vtkDiskSource* sself); +extern "C" double vtk_disk_source_get_outer_radius_max_value(vtkDiskSource* sself); +extern "C" double vtk_disk_source_get_outer_radius(vtkDiskSource* sself); +extern "C" void vtk_disk_source_set_radial_resolution(vtkDiskSource* sself, int _arg); +extern "C" int vtk_disk_source_get_radial_resolution_min_value(vtkDiskSource* sself); +extern "C" int vtk_disk_source_get_radial_resolution_max_value(vtkDiskSource* sself); +extern "C" int vtk_disk_source_get_radial_resolution(vtkDiskSource* sself); +extern "C" void vtk_disk_source_set_circumferential_resolution(vtkDiskSource* sself, int _arg); +extern "C" int vtk_disk_source_get_circumferential_resolution_min_value(vtkDiskSource* sself); +extern "C" int vtk_disk_source_get_circumferential_resolution_max_value(vtkDiskSource* sself); +extern "C" int vtk_disk_source_get_circumferential_resolution(vtkDiskSource* sself); +extern "C" void vtk_disk_source_set_output_points_precision(vtkDiskSource* sself, int _arg); +extern "C" int vtk_disk_source_get_output_points_precision(vtkDiskSource* sself); +extern "C" vtkEllipseArcSource * vtkEllipseArcSource_new () ; +extern "C" void vtkEllipseArcSource_destructor (vtkEllipseArcSource * sself) ; +extern "C" void vtk_ellipse_arc_source_set_center(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_ellipse_arc_source_set_normal(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_ellipse_arc_source_set_major_radius_vector(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_ellipse_arc_source_set_start_angle(vtkEllipseArcSource* sself, double _arg); +extern "C" double vtk_ellipse_arc_source_get_start_angle_min_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_start_angle_max_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_start_angle(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_segment_angle(vtkEllipseArcSource* sself, double _arg); +extern "C" double vtk_ellipse_arc_source_get_segment_angle_min_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_segment_angle_max_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_segment_angle(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_resolution(vtkEllipseArcSource* sself, int _arg); +extern "C" int vtk_ellipse_arc_source_get_resolution_min_value(vtkEllipseArcSource* sself); +extern "C" int vtk_ellipse_arc_source_get_resolution_max_value(vtkEllipseArcSource* sself); +extern "C" int vtk_ellipse_arc_source_get_resolution(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_close(vtkEllipseArcSource* sself, bool _arg); +extern "C" bool vtk_ellipse_arc_source_get_close(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_close_on(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_close_off(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_output_points_precision(vtkEllipseArcSource* sself, int _arg); +extern "C" int vtk_ellipse_arc_source_get_output_points_precision(vtkEllipseArcSource* sself); +extern "C" void vtk_ellipse_arc_source_set_ratio(vtkEllipseArcSource* sself, double _arg); +extern "C" double vtk_ellipse_arc_source_get_ratio_min_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_ratio_max_value(vtkEllipseArcSource* sself); +extern "C" double vtk_ellipse_arc_source_get_ratio(vtkEllipseArcSource* sself); +extern "C" vtkEllipticalButtonSource * vtkEllipticalButtonSource_new () ; +extern "C" void vtkEllipticalButtonSource_destructor (vtkEllipticalButtonSource * sself) ; +extern "C" void vtk_elliptical_button_source_set_width(vtkEllipticalButtonSource* sself, double _arg); +extern "C" double vtk_elliptical_button_source_get_width_min_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_width_max_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_width(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_height(vtkEllipticalButtonSource* sself, double _arg); +extern "C" double vtk_elliptical_button_source_get_height_min_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_height_max_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_height(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_depth(vtkEllipticalButtonSource* sself, double _arg); +extern "C" double vtk_elliptical_button_source_get_depth_min_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_depth_max_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_depth(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_circumferential_resolution(vtkEllipticalButtonSource* sself, int _arg); +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution_min_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution_max_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_texture_resolution(vtkEllipticalButtonSource* sself, int _arg); +extern "C" int vtk_elliptical_button_source_get_texture_resolution_min_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_texture_resolution_max_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_texture_resolution(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_shoulder_resolution(vtkEllipticalButtonSource* sself, int _arg); +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution_min_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution_max_value(vtkEllipticalButtonSource* sself); +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_radial_ratio(vtkEllipticalButtonSource* sself, double _arg); +extern "C" double vtk_elliptical_button_source_get_radial_ratio_min_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_radial_ratio_max_value(vtkEllipticalButtonSource* sself); +extern "C" double vtk_elliptical_button_source_get_radial_ratio(vtkEllipticalButtonSource* sself); +extern "C" void vtk_elliptical_button_source_set_output_points_precision(vtkEllipticalButtonSource* sself, int _arg); +extern "C" int vtk_elliptical_button_source_get_output_points_precision(vtkEllipticalButtonSource* sself); +extern "C" vtkFrustumSource * vtkFrustumSource_new () ; +extern "C" void vtkFrustumSource_destructor (vtkFrustumSource * sself) ; +extern "C" bool vtk_frustum_source_get_show_lines(vtkFrustumSource* sself); +extern "C" void vtk_frustum_source_set_show_lines(vtkFrustumSource* sself, bool _arg); +extern "C" void vtk_frustum_source_show_lines_on(vtkFrustumSource* sself); +extern "C" void vtk_frustum_source_show_lines_off(vtkFrustumSource* sself); +extern "C" double vtk_frustum_source_get_lines_length(vtkFrustumSource* sself); +extern "C" void vtk_frustum_source_set_lines_length(vtkFrustumSource* sself, double _arg); +extern "C" unsigned long vtk_frustum_source_get_m_time(vtkFrustumSource* sself); +extern "C" void vtk_frustum_source_set_output_points_precision(vtkFrustumSource* sself, int _arg); +extern "C" int vtk_frustum_source_get_output_points_precision(vtkFrustumSource* sself); +extern "C" vtkGlyphSource2D * vtkGlyphSource2D_new () ; +extern "C" void vtkGlyphSource2D_destructor (vtkGlyphSource2D * sself) ; +extern "C" void vtk_glyph_source_2_d_set_center(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_glyph_source_2_d_set_scale(vtkGlyphSource2D* sself, double _arg); +extern "C" double vtk_glyph_source_2_d_get_scale_min_value(vtkGlyphSource2D* sself); +extern "C" double vtk_glyph_source_2_d_get_scale_max_value(vtkGlyphSource2D* sself); +extern "C" double vtk_glyph_source_2_d_get_scale(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_scale_2(vtkGlyphSource2D* sself, double _arg); +extern "C" double vtk_glyph_source_2_d_get_scale_2_min_value(vtkGlyphSource2D* sself); +extern "C" double vtk_glyph_source_2_d_get_scale_2_max_value(vtkGlyphSource2D* sself); +extern "C" double vtk_glyph_source_2_d_get_scale_2(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_color(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_glyph_source_2_d_set_filled(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_filled(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_filled_on(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_filled_off(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_dash(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_dash(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_dash_on(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_dash_off(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_cross(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_cross(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_cross_on(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_cross_off(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_rotation_angle(vtkGlyphSource2D* sself, double _arg); +extern "C" double vtk_glyph_source_2_d_get_rotation_angle(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_resolution(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_resolution_min_value(vtkGlyphSource2D* sself); +extern "C" int vtk_glyph_source_2_d_get_resolution_max_value(vtkGlyphSource2D* sself); +extern "C" int vtk_glyph_source_2_d_get_resolution(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_glyph_type_min_value(vtkGlyphSource2D* sself); +extern "C" int vtk_glyph_source_2_d_get_glyph_type_max_value(vtkGlyphSource2D* sself); +extern "C" int vtk_glyph_source_2_d_get_glyph_type(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_none(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_vertex(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_dash(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_cross(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_thick_cross(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_triangle(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_square(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_circle(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_diamond(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_arrow(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_thick_arrow(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_hooked_arrow(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_edge_arrow(vtkGlyphSource2D* sself); +extern "C" void vtk_glyph_source_2_d_set_output_points_precision(vtkGlyphSource2D* sself, int _arg); +extern "C" int vtk_glyph_source_2_d_get_output_points_precision(vtkGlyphSource2D* sself); +extern "C" vtkGraphToPolyData * vtkGraphToPolyData_new () ; +extern "C" void vtkGraphToPolyData_destructor (vtkGraphToPolyData * sself) ; +extern "C" void vtk_graph_to_poly_data_set_edge_glyph_output(vtkGraphToPolyData* sself, bool _arg); +extern "C" bool vtk_graph_to_poly_data_get_edge_glyph_output(vtkGraphToPolyData* sself); +extern "C" void vtk_graph_to_poly_data_edge_glyph_output_on(vtkGraphToPolyData* sself); +extern "C" void vtk_graph_to_poly_data_edge_glyph_output_off(vtkGraphToPolyData* sself); +extern "C" void vtk_graph_to_poly_data_set_edge_glyph_position(vtkGraphToPolyData* sself, double _arg); +extern "C" double vtk_graph_to_poly_data_get_edge_glyph_position(vtkGraphToPolyData* sself); +extern "C" vtkHyperTreeGridSource * vtkHyperTreeGridSource_new () ; +extern "C" void vtkHyperTreeGridSource_destructor (vtkHyperTreeGridSource * sself) ; +extern "C" unsigned int vtk_hyper_tree_grid_source_get_maximum_level(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_maximum_level(vtkHyperTreeGridSource* sself, unsigned int levels); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_max_depth(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_max_depth(vtkHyperTreeGridSource* sself, unsigned int levels); +extern "C" void vtk_hyper_tree_grid_source_set_origin(vtkHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_hyper_tree_grid_source_set_grid_scale(vtkHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_hyper_tree_grid_source_set_transposed_root_indexing(vtkHyperTreeGridSource* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_source_get_transposed_root_indexing(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_indexing_mode_to_kji(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_indexing_mode_to_ijk(vtkHyperTreeGridSource* sself); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_orientation(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_branch_factor(vtkHyperTreeGridSource* sself, unsigned int _arg); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor_min_value(vtkHyperTreeGridSource* sself); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor_max_value(vtkHyperTreeGridSource* sself); +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_use_descriptor(vtkHyperTreeGridSource* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_source_get_use_descriptor(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_use_descriptor_on(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_use_descriptor_off(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_use_mask(vtkHyperTreeGridSource* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_source_get_use_mask(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_use_mask_on(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_use_mask_off(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_generate_interface_fields(vtkHyperTreeGridSource* sself, bool _arg); +extern "C" bool vtk_hyper_tree_grid_source_get_generate_interface_fields(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_generate_interface_fields_on(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_generate_interface_fields_off(vtkHyperTreeGridSource* sself); +extern "C" void vtk_hyper_tree_grid_source_set_descriptor(vtkHyperTreeGridSource* sself, const char* _arg); +extern "C" void vtk_hyper_tree_grid_source_set_mask(vtkHyperTreeGridSource* sself, const char* _arg); +extern "C" unsigned long vtk_hyper_tree_grid_source_get_m_time(vtkHyperTreeGridSource* sself); +extern "C" vtkLineSource * vtkLineSource_new () ; +extern "C" void vtkLineSource_destructor (vtkLineSource * sself) ; +extern "C" void vtk_line_source_set_point_1(vtkLineSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_line_source_set_point_2(vtkLineSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_line_source_set_use_regular_refinement(vtkLineSource* sself, bool _arg); +extern "C" bool vtk_line_source_get_use_regular_refinement(vtkLineSource* sself); +extern "C" void vtk_line_source_use_regular_refinement_on(vtkLineSource* sself); +extern "C" void vtk_line_source_use_regular_refinement_off(vtkLineSource* sself); +extern "C" void vtk_line_source_set_resolution(vtkLineSource* sself, int _arg); +extern "C" int vtk_line_source_get_resolution_min_value(vtkLineSource* sself); +extern "C" int vtk_line_source_get_resolution_max_value(vtkLineSource* sself); +extern "C" int vtk_line_source_get_resolution(vtkLineSource* sself); +extern "C" void vtk_line_source_set_number_of_refinement_ratios(vtkLineSource* sself, int p0); +extern "C" void vtk_line_source_set_refinement_ratio(vtkLineSource* sself, int index, double value); +extern "C" int vtk_line_source_get_number_of_refinement_ratios(vtkLineSource* sself); +extern "C" double vtk_line_source_get_refinement_ratio(vtkLineSource* sself, int index); +extern "C" void vtk_line_source_set_output_points_precision(vtkLineSource* sself, int _arg); +extern "C" int vtk_line_source_get_output_points_precision(vtkLineSource* sself); +extern "C" vtkOutlineCornerFilter * vtkOutlineCornerFilter_new () ; +extern "C" void vtkOutlineCornerFilter_destructor (vtkOutlineCornerFilter * sself) ; +extern "C" void vtk_outline_corner_filter_set_corner_factor(vtkOutlineCornerFilter* sself, double _arg); +extern "C" double vtk_outline_corner_filter_get_corner_factor_min_value(vtkOutlineCornerFilter* sself); +extern "C" double vtk_outline_corner_filter_get_corner_factor_max_value(vtkOutlineCornerFilter* sself); +extern "C" double vtk_outline_corner_filter_get_corner_factor(vtkOutlineCornerFilter* sself); +extern "C" vtkOutlineCornerSource * vtkOutlineCornerSource_new () ; +extern "C" void vtkOutlineCornerSource_destructor (vtkOutlineCornerSource * sself) ; +extern "C" void vtk_outline_corner_source_set_corner_factor(vtkOutlineCornerSource* sself, double _arg); +extern "C" double vtk_outline_corner_source_get_corner_factor_min_value(vtkOutlineCornerSource* sself); +extern "C" double vtk_outline_corner_source_get_corner_factor_max_value(vtkOutlineCornerSource* sself); +extern "C" double vtk_outline_corner_source_get_corner_factor(vtkOutlineCornerSource* sself); +extern "C" vtkOutlineSource * vtkOutlineSource_new () ; +extern "C" void vtkOutlineSource_destructor (vtkOutlineSource * sself) ; +extern "C" void vtk_outline_source_set_box_type(vtkOutlineSource* sself, int _arg); +extern "C" int vtk_outline_source_get_box_type(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_set_box_type_to_axis_aligned(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_set_box_type_to_oriented(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_set_bounds(vtkOutlineSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6); +extern "C" void vtk_outline_source_set_generate_faces(vtkOutlineSource* sself, int _arg); +extern "C" void vtk_outline_source_generate_faces_on(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_generate_faces_off(vtkOutlineSource* sself); +extern "C" int vtk_outline_source_get_generate_faces(vtkOutlineSource* sself); +extern "C" void vtk_outline_source_set_output_points_precision(vtkOutlineSource* sself, int _arg); +extern "C" int vtk_outline_source_get_output_points_precision(vtkOutlineSource* sself); +extern "C" vtkParametricFunctionSource * vtkParametricFunctionSource_new () ; +extern "C" void vtkParametricFunctionSource_destructor (vtkParametricFunctionSource * sself) ; +extern "C" void vtk_parametric_function_source_set_u_resolution(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_u_resolution_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_u_resolution_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_u_resolution(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_v_resolution(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_v_resolution_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_v_resolution_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_v_resolution(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_w_resolution(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_w_resolution_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_w_resolution_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_w_resolution(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_generate_texture_coordinates_on(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_generate_texture_coordinates_off(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_generate_texture_coordinates(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_generate_normals_on(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_generate_normals_off(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_generate_normals(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_generate_normals_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_generate_normals_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_generate_normals(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_scalar_mode_min_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_scalar_mode_max_value(vtkParametricFunctionSource* sself); +extern "C" int vtk_parametric_function_source_get_scalar_mode(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_none(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_v(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u_0(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_v_0(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u_0_v_0(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_modulus(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_phase(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_quadrant(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_x(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_y(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_z(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_distance(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_function_defined(vtkParametricFunctionSource* sself); +extern "C" unsigned long vtk_parametric_function_source_get_m_time(vtkParametricFunctionSource* sself); +extern "C" void vtk_parametric_function_source_set_output_points_precision(vtkParametricFunctionSource* sself, int _arg); +extern "C" int vtk_parametric_function_source_get_output_points_precision(vtkParametricFunctionSource* sself); +extern "C" vtkPartitionedDataSetCollectionSource * vtkPartitionedDataSetCollectionSource_new () ; +extern "C" void vtkPartitionedDataSetCollectionSource_destructor (vtkPartitionedDataSetCollectionSource * sself) ; +extern "C" void vtk_partitioned_data_set_collection_source_set_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself, int _arg); +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value(vtkPartitionedDataSetCollectionSource* sself); +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value(vtkPartitionedDataSetCollectionSource* sself); +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself); +extern "C" vtkPartitionedDataSetSource * vtkPartitionedDataSetSource_new () ; +extern "C" void vtkPartitionedDataSetSource_destructor (vtkPartitionedDataSetSource * sself) ; +extern "C" void vtk_partitioned_data_set_source_enable_rank(vtkPartitionedDataSetSource* sself, int rank); +extern "C" void vtk_partitioned_data_set_source_enable_all_ranks(vtkPartitionedDataSetSource* sself); +extern "C" void vtk_partitioned_data_set_source_disable_rank(vtkPartitionedDataSetSource* sself, int rank); +extern "C" void vtk_partitioned_data_set_source_disable_all_ranks(vtkPartitionedDataSetSource* sself); +extern "C" bool vtk_partitioned_data_set_source_is_enabled_rank(vtkPartitionedDataSetSource* sself, int rank); +extern "C" void vtk_partitioned_data_set_source_set_number_of_partitions(vtkPartitionedDataSetSource* sself, int _arg); +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_min_value(vtkPartitionedDataSetSource* sself); +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_max_value(vtkPartitionedDataSetSource* sself); +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions(vtkPartitionedDataSetSource* sself); +extern "C" vtkPlaneSource * vtkPlaneSource_new () ; +extern "C" void vtkPlaneSource_destructor (vtkPlaneSource * sself) ; +extern "C" void vtk_plane_source_set_x_resolution(vtkPlaneSource* sself, int _arg); +extern "C" int vtk_plane_source_get_x_resolution(vtkPlaneSource* sself); +extern "C" void vtk_plane_source_set_y_resolution(vtkPlaneSource* sself, int _arg); +extern "C" int vtk_plane_source_get_y_resolution(vtkPlaneSource* sself); +extern "C" void vtk_plane_source_set_resolution(vtkPlaneSource* sself, const int xR, const int yR); +extern "C" void vtk_plane_source_get_resolution(vtkPlaneSource* sself, int& xR, int& yR); +extern "C" void vtk_plane_source_set_origin(vtkPlaneSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_plane_source_set_point_1(vtkPlaneSource* sself, double x, double y, double z); +extern "C" void vtk_plane_source_set_point_2(vtkPlaneSource* sself, double x, double y, double z); +extern "C" void vtk_plane_source_set_center(vtkPlaneSource* sself, double x, double y, double z); +extern "C" void vtk_plane_source_set_normal(vtkPlaneSource* sself, double nx, double ny, double nz); +extern "C" void vtk_plane_source_push(vtkPlaneSource* sself, double distance); +extern "C" void vtk_plane_source_set_output_points_precision(vtkPlaneSource* sself, int _arg); +extern "C" int vtk_plane_source_get_output_points_precision(vtkPlaneSource* sself); +extern "C" vtkPlatonicSolidSource * vtkPlatonicSolidSource_new () ; +extern "C" void vtkPlatonicSolidSource_destructor (vtkPlatonicSolidSource * sself) ; +extern "C" void vtk_platonic_solid_source_set_solid_type(vtkPlatonicSolidSource* sself, int _arg); +extern "C" int vtk_platonic_solid_source_get_solid_type_min_value(vtkPlatonicSolidSource* sself); +extern "C" int vtk_platonic_solid_source_get_solid_type_max_value(vtkPlatonicSolidSource* sself); +extern "C" int vtk_platonic_solid_source_get_solid_type(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_tetrahedron(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_cube(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_octahedron(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_icosahedron(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_solid_type_to_dodecahedron(vtkPlatonicSolidSource* sself); +extern "C" void vtk_platonic_solid_source_set_output_points_precision(vtkPlatonicSolidSource* sself, int _arg); +extern "C" int vtk_platonic_solid_source_get_output_points_precision(vtkPlatonicSolidSource* sself); +extern "C" vtkPointHandleSource * vtkPointHandleSource_new () ; +extern "C" void vtkPointHandleSource_destructor (vtkPointHandleSource * sself) ; +extern "C" void vtk_point_handle_source_set_position(vtkPointHandleSource* sself, double xPos, double yPos, double zPos); +extern "C" void vtk_point_handle_source_set_direction(vtkPointHandleSource* sself, double xDir, double yDir, double zDir); +extern "C" vtkPointSource * vtkPointSource_new () ; +extern "C" void vtkPointSource_destructor (vtkPointSource * sself) ; +extern "C" void vtk_point_source_set_number_of_points(vtkPointSource* sself, long long _arg); +extern "C" long long vtk_point_source_get_number_of_points_min_value(vtkPointSource* sself); +extern "C" long long vtk_point_source_get_number_of_points_max_value(vtkPointSource* sself); +extern "C" long long vtk_point_source_get_number_of_points(vtkPointSource* sself); +extern "C" void vtk_point_source_set_center(vtkPointSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_point_source_set_radius(vtkPointSource* sself, double _arg); +extern "C" double vtk_point_source_get_radius_min_value(vtkPointSource* sself); +extern "C" double vtk_point_source_get_radius_max_value(vtkPointSource* sself); +extern "C" double vtk_point_source_get_radius(vtkPointSource* sself); +extern "C" void vtk_point_source_set_distribution(vtkPointSource* sself, int _arg); +extern "C" void vtk_point_source_set_distribution_to_uniform(vtkPointSource* sself); +extern "C" void vtk_point_source_set_distribution_to_shell(vtkPointSource* sself); +extern "C" int vtk_point_source_get_distribution(vtkPointSource* sself); +extern "C" void vtk_point_source_set_output_points_precision(vtkPointSource* sself, int _arg); +extern "C" int vtk_point_source_get_output_points_precision(vtkPointSource* sself); +extern "C" vtkPolyLineSource * vtkPolyLineSource_new () ; +extern "C" void vtkPolyLineSource_destructor (vtkPolyLineSource * sself) ; +extern "C" void vtk_poly_line_source_set_closed(vtkPolyLineSource* sself, int _arg); +extern "C" int vtk_poly_line_source_get_closed(vtkPolyLineSource* sself); +extern "C" void vtk_poly_line_source_closed_on(vtkPolyLineSource* sself); +extern "C" void vtk_poly_line_source_closed_off(vtkPolyLineSource* sself); +extern "C" vtkPolyPointSource * vtkPolyPointSource_new () ; +extern "C" void vtkPolyPointSource_destructor (vtkPolyPointSource * sself) ; +extern "C" void vtk_poly_point_source_set_number_of_points(vtkPolyPointSource* sself, long long numPoints); +extern "C" long long vtk_poly_point_source_get_number_of_points(vtkPolyPointSource* sself); +extern "C" void vtk_poly_point_source_resize(vtkPolyPointSource* sself, long long numPoints); +extern "C" void vtk_poly_point_source_set_point(vtkPolyPointSource* sself, long long id, double x, double y, double z); +extern "C" unsigned long vtk_poly_point_source_get_m_time(vtkPolyPointSource* sself); +extern "C" vtkProgrammableDataObjectSource * vtkProgrammableDataObjectSource_new () ; +extern "C" void vtkProgrammableDataObjectSource_destructor (vtkProgrammableDataObjectSource * sself) ; +extern "C" vtkProgrammableSource * vtkProgrammableSource_new () ; +extern "C" void vtkProgrammableSource_destructor (vtkProgrammableSource * sself) ; +extern "C" vtkRandomHyperTreeGridSource * vtkRandomHyperTreeGridSource_new () ; +extern "C" void vtkRandomHyperTreeGridSource_destructor (vtkRandomHyperTreeGridSource * sself) ; +extern "C" void vtk_random_hyper_tree_grid_source_set_dimensions(vtkRandomHyperTreeGridSource* sself, unsigned int _arg1, unsigned int _arg2, unsigned int _arg3); +extern "C" void vtk_random_hyper_tree_grid_source_set_output_bounds(vtkRandomHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6); +extern "C" unsigned int vtk_random_hyper_tree_grid_source_get_seed(vtkRandomHyperTreeGridSource* sself); +extern "C" void vtk_random_hyper_tree_grid_source_set_seed(vtkRandomHyperTreeGridSource* sself, unsigned int _arg); +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth(vtkRandomHyperTreeGridSource* sself); +extern "C" void vtk_random_hyper_tree_grid_source_set_max_depth(vtkRandomHyperTreeGridSource* sself, long long _arg); +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth_min_value(vtkRandomHyperTreeGridSource* sself); +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth_max_value(vtkRandomHyperTreeGridSource* sself); +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction(vtkRandomHyperTreeGridSource* sself); +extern "C" void vtk_random_hyper_tree_grid_source_set_split_fraction(vtkRandomHyperTreeGridSource* sself, double _arg); +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_min_value(vtkRandomHyperTreeGridSource* sself); +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_max_value(vtkRandomHyperTreeGridSource* sself); +extern "C" vtkRectangularButtonSource * vtkRectangularButtonSource_new () ; +extern "C" void vtkRectangularButtonSource_destructor (vtkRectangularButtonSource * sself) ; +extern "C" void vtk_rectangular_button_source_set_width(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_width_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_width_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_width(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_height(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_height_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_height_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_height(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_depth(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_depth_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_depth_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_depth(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_box_ratio(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_box_ratio_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_box_ratio_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_box_ratio(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_texture_ratio(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_texture_ratio_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_texture_ratio_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_texture_ratio(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_texture_height_ratio(vtkRectangularButtonSource* sself, double _arg); +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio_min_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio_max_value(vtkRectangularButtonSource* sself); +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio(vtkRectangularButtonSource* sself); +extern "C" void vtk_rectangular_button_source_set_output_points_precision(vtkRectangularButtonSource* sself, int _arg); +extern "C" int vtk_rectangular_button_source_get_output_points_precision(vtkRectangularButtonSource* sself); +extern "C" vtkRegularPolygonSource * vtkRegularPolygonSource_new () ; +extern "C" void vtkRegularPolygonSource_destructor (vtkRegularPolygonSource * sself) ; +extern "C" void vtk_regular_polygon_source_set_number_of_sides(vtkRegularPolygonSource* sself, int _arg); +extern "C" int vtk_regular_polygon_source_get_number_of_sides_min_value(vtkRegularPolygonSource* sself); +extern "C" int vtk_regular_polygon_source_get_number_of_sides_max_value(vtkRegularPolygonSource* sself); +extern "C" int vtk_regular_polygon_source_get_number_of_sides(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_set_center(vtkRegularPolygonSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_regular_polygon_source_set_normal(vtkRegularPolygonSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_regular_polygon_source_set_radius(vtkRegularPolygonSource* sself, double _arg); +extern "C" double vtk_regular_polygon_source_get_radius(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_set_generate_polygon(vtkRegularPolygonSource* sself, int _arg); +extern "C" int vtk_regular_polygon_source_get_generate_polygon(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_generate_polygon_on(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_generate_polygon_off(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_set_generate_polyline(vtkRegularPolygonSource* sself, int _arg); +extern "C" int vtk_regular_polygon_source_get_generate_polyline(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_generate_polyline_on(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_generate_polyline_off(vtkRegularPolygonSource* sself); +extern "C" void vtk_regular_polygon_source_set_output_points_precision(vtkRegularPolygonSource* sself, int _arg); +extern "C" int vtk_regular_polygon_source_get_output_points_precision(vtkRegularPolygonSource* sself); +extern "C" vtkSelectionSource * vtkSelectionSource_new () ; +extern "C" void vtkSelectionSource_destructor (vtkSelectionSource * sself) ; +extern "C" void vtk_selection_source_add_id(vtkSelectionSource* sself, long long piece, long long id); +extern "C" void vtk_selection_source_add_string_id(vtkSelectionSource* sself, long long piece, const char* id); +extern "C" void vtk_selection_source_add_location(vtkSelectionSource* sself, double x, double y, double z); +extern "C" void vtk_selection_source_add_threshold(vtkSelectionSource* sself, double min, double max); +extern "C" void vtk_selection_source_add_block(vtkSelectionSource* sself, long long blockno); +extern "C" void vtk_selection_source_add_block_selector(vtkSelectionSource* sself, const char* selector); +extern "C" void vtk_selection_source_remove_all_block_selectors(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_i_ds(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_string_i_ds(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_thresholds(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_locations(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_remove_all_blocks(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_content_type(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_content_type(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_field_type(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_field_type(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_containing_cells(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_containing_cells(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_number_of_layers(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_number_of_layers_min_value(vtkSelectionSource* sself); +extern "C" int vtk_selection_source_get_number_of_layers_max_value(vtkSelectionSource* sself); +extern "C" int vtk_selection_source_get_number_of_layers(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_inverse(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_inverse(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_array_name(vtkSelectionSource* sself, const char* _arg); +extern "C" void vtk_selection_source_set_array_component(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_array_component(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_composite_index(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_composite_index(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_hierarchical_level(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_hierarchical_level(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_hierarchical_index(vtkSelectionSource* sself, int _arg); +extern "C" int vtk_selection_source_get_hierarchical_index(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_assembly_name(vtkSelectionSource* sself, const char* _arg); +extern "C" void vtk_selection_source_add_selector(vtkSelectionSource* sself, const char* selector); +extern "C" void vtk_selection_source_remove_all_selectors(vtkSelectionSource* sself); +extern "C" void vtk_selection_source_set_query_string(vtkSelectionSource* sself, const char* _arg); +extern "C" vtkSphereSource * vtkSphereSource_new () ; +extern "C" void vtkSphereSource_destructor (vtkSphereSource * sself) ; +extern "C" void vtk_sphere_source_set_radius(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_radius_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_radius_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_radius(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_center(vtkSphereSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_sphere_source_set_theta_resolution(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_theta_resolution_min_value(vtkSphereSource* sself); +extern "C" int vtk_sphere_source_get_theta_resolution_max_value(vtkSphereSource* sself); +extern "C" int vtk_sphere_source_get_theta_resolution(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_phi_resolution(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_phi_resolution_min_value(vtkSphereSource* sself); +extern "C" int vtk_sphere_source_get_phi_resolution_max_value(vtkSphereSource* sself); +extern "C" int vtk_sphere_source_get_phi_resolution(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_start_theta(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_start_theta_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_start_theta_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_start_theta(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_end_theta(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_end_theta_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_end_theta_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_end_theta(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_start_phi(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_start_phi_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_start_phi_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_start_phi(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_end_phi(vtkSphereSource* sself, double _arg); +extern "C" double vtk_sphere_source_get_end_phi_min_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_end_phi_max_value(vtkSphereSource* sself); +extern "C" double vtk_sphere_source_get_end_phi(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_lat_long_tessellation(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_lat_long_tessellation(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_lat_long_tessellation_on(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_lat_long_tessellation_off(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_output_points_precision(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_output_points_precision(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_set_generate_normals(vtkSphereSource* sself, int _arg); +extern "C" int vtk_sphere_source_get_generate_normals(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_generate_normals_on(vtkSphereSource* sself); +extern "C" void vtk_sphere_source_generate_normals_off(vtkSphereSource* sself); +extern "C" vtkSuperquadricSource * vtkSuperquadricSource_new () ; +extern "C" void vtkSuperquadricSource_destructor (vtkSuperquadricSource * sself) ; +extern "C" void vtk_superquadric_source_set_center(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_superquadric_source_set_scale(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" int vtk_superquadric_source_get_theta_resolution(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_theta_resolution(vtkSuperquadricSource* sself, int i); +extern "C" int vtk_superquadric_source_get_phi_resolution(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_phi_resolution(vtkSuperquadricSource* sself, int i); +extern "C" double vtk_superquadric_source_get_thickness(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_thickness(vtkSuperquadricSource* sself, double _arg); +extern "C" double vtk_superquadric_source_get_thickness_min_value(vtkSuperquadricSource* sself); +extern "C" double vtk_superquadric_source_get_thickness_max_value(vtkSuperquadricSource* sself); +extern "C" double vtk_superquadric_source_get_phi_roundness(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_phi_roundness(vtkSuperquadricSource* sself, double e); +extern "C" double vtk_superquadric_source_get_theta_roundness(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_theta_roundness(vtkSuperquadricSource* sself, double e); +extern "C" void vtk_superquadric_source_set_size(vtkSuperquadricSource* sself, double _arg); +extern "C" double vtk_superquadric_source_get_size(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_axis_of_symmetry(vtkSuperquadricSource* sself, int _arg); +extern "C" int vtk_superquadric_source_get_axis_of_symmetry(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_x_axis_of_symmetry(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_y_axis_of_symmetry(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_z_axis_of_symmetry(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_toroidal_on(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_toroidal_off(vtkSuperquadricSource* sself); +extern "C" int vtk_superquadric_source_get_toroidal(vtkSuperquadricSource* sself); +extern "C" void vtk_superquadric_source_set_toroidal(vtkSuperquadricSource* sself, int _arg); +extern "C" void vtk_superquadric_source_set_output_points_precision(vtkSuperquadricSource* sself, int _arg); +extern "C" int vtk_superquadric_source_get_output_points_precision(vtkSuperquadricSource* sself); +extern "C" vtkTessellatedBoxSource * vtkTessellatedBoxSource_new () ; +extern "C" void vtkTessellatedBoxSource_destructor (vtkTessellatedBoxSource * sself) ; +extern "C" void vtk_tessellated_box_source_set_bounds(vtkTessellatedBoxSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6); +extern "C" void vtk_tessellated_box_source_set_level(vtkTessellatedBoxSource* sself, int _arg); +extern "C" int vtk_tessellated_box_source_get_level(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_set_duplicate_shared_points(vtkTessellatedBoxSource* sself, int _arg); +extern "C" int vtk_tessellated_box_source_get_duplicate_shared_points(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_duplicate_shared_points_on(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_duplicate_shared_points_off(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_set_quads(vtkTessellatedBoxSource* sself, int _arg); +extern "C" int vtk_tessellated_box_source_get_quads(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_quads_on(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_quads_off(vtkTessellatedBoxSource* sself); +extern "C" void vtk_tessellated_box_source_set_output_points_precision(vtkTessellatedBoxSource* sself, int _arg); +extern "C" int vtk_tessellated_box_source_get_output_points_precision(vtkTessellatedBoxSource* sself); +extern "C" vtkTextSource * vtkTextSource_new () ; +extern "C" void vtkTextSource_destructor (vtkTextSource * sself) ; +extern "C" void vtk_text_source_set_text(vtkTextSource* sself, const char* _arg); +extern "C" void vtk_text_source_set_backing(vtkTextSource* sself, int _arg); +extern "C" int vtk_text_source_get_backing(vtkTextSource* sself); +extern "C" void vtk_text_source_backing_on(vtkTextSource* sself); +extern "C" void vtk_text_source_backing_off(vtkTextSource* sself); +extern "C" void vtk_text_source_set_foreground_color(vtkTextSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_text_source_set_background_color(vtkTextSource* sself, double _arg1, double _arg2, double _arg3); +extern "C" void vtk_text_source_set_output_points_precision(vtkTextSource* sself, int _arg); +extern "C" int vtk_text_source_get_output_points_precision(vtkTextSource* sself); +extern "C" vtkTexturedSphereSource * vtkTexturedSphereSource_new () ; +extern "C" void vtkTexturedSphereSource_destructor (vtkTexturedSphereSource * sself) ; +extern "C" void vtk_textured_sphere_source_set_radius(vtkTexturedSphereSource* sself, double _arg); +extern "C" double vtk_textured_sphere_source_get_radius_min_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_radius_max_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_radius(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_theta_resolution(vtkTexturedSphereSource* sself, int _arg); +extern "C" int vtk_textured_sphere_source_get_theta_resolution_min_value(vtkTexturedSphereSource* sself); +extern "C" int vtk_textured_sphere_source_get_theta_resolution_max_value(vtkTexturedSphereSource* sself); +extern "C" int vtk_textured_sphere_source_get_theta_resolution(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_phi_resolution(vtkTexturedSphereSource* sself, int _arg); +extern "C" int vtk_textured_sphere_source_get_phi_resolution_min_value(vtkTexturedSphereSource* sself); +extern "C" int vtk_textured_sphere_source_get_phi_resolution_max_value(vtkTexturedSphereSource* sself); +extern "C" int vtk_textured_sphere_source_get_phi_resolution(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_theta(vtkTexturedSphereSource* sself, double _arg); +extern "C" double vtk_textured_sphere_source_get_theta_min_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_theta_max_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_theta(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_phi(vtkTexturedSphereSource* sself, double _arg); +extern "C" double vtk_textured_sphere_source_get_phi_min_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_phi_max_value(vtkTexturedSphereSource* sself); +extern "C" double vtk_textured_sphere_source_get_phi(vtkTexturedSphereSource* sself); +extern "C" void vtk_textured_sphere_source_set_output_points_precision(vtkTexturedSphereSource* sself, int _arg); +extern "C" int vtk_textured_sphere_source_get_output_points_precision(vtkTexturedSphereSource* sself); +extern "C" vtkUniformHyperTreeGridSource * vtkUniformHyperTreeGridSource_new () ; +extern "C" void vtkUniformHyperTreeGridSource_destructor (vtkUniformHyperTreeGridSource * sself) ; diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_archive.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_archive.cpp index 1ebfbe0..11eff3a 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_archive.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_archive.cpp @@ -13,6 +13,10 @@ extern "C" vtkNew < vtkBufferedArchiver > vtkBufferedArchiver_new () {return vtkNew < vtkBufferedArchiver > () ;} extern "C" void vtkBufferedArchiver_destructor (vtkNew < vtkBufferedArchiver > sself) {sself . Reset () ; return ;} extern "C" void * vtkBufferedArchiver_get_ptr (vtkNew < vtkBufferedArchiver > sself) {return sself . GetPointer () ;} +extern "C" void vtkBufferedArchiver_set_archive_name (vtkNew < vtkBufferedArchiver > sself, const char * name) {sself->SetArchiveName(name);} +extern "C" const char * vtkBufferedArchiver_get_archive_name (vtkNew < vtkBufferedArchiver > sself) {return sself->GetArchiveName();} extern "C" vtkNew < vtkPartitionedArchiver > vtkPartitionedArchiver_new () {return vtkNew < vtkPartitionedArchiver > () ;} extern "C" void vtkPartitionedArchiver_destructor (vtkNew < vtkPartitionedArchiver > sself) {sself . Reset () ; return ;} extern "C" void * vtkPartitionedArchiver_get_ptr (vtkNew < vtkPartitionedArchiver > sself) {return sself . GetPointer () ;} +extern "C" void vtkPartitionedArchiver_set_archive_name (vtkNew < vtkPartitionedArchiver > sself, const char * name) {sself->SetArchiveName(name);} +extern "C" const char * vtkPartitionedArchiver_get_archive_name (vtkNew < vtkPartitionedArchiver > sself) {return sself->GetArchiveName();} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp index 9b219b4..fa2697d 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_color.cpp @@ -10,9 +10,16 @@ #include // Implement declared functions -extern "C" vtkNew < vtkColorSeries > vtkColorSeries_new () {return vtkNew < vtkColorSeries > () ;} -extern "C" void vtkColorSeries_destructor (vtkNew < vtkColorSeries > sself) {sself . Reset () ; return ;} -extern "C" void * vtkColorSeries_get_ptr (vtkNew < vtkColorSeries > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkNamedColors > vtkNamedColors_new () {return vtkNew < vtkNamedColors > () ;} -extern "C" void vtkNamedColors_destructor (vtkNew < vtkNamedColors > sself) {sself . Reset () ; return ;} -extern "C" void * vtkNamedColors_get_ptr (vtkNew < vtkNamedColors > sself) {return sself . GetPointer () ;} +extern "C" vtkColorSeries * vtkColorSeries_new () {return vtkColorSeries :: New () ;} +extern "C" void vtkColorSeries_destructor (vtkColorSeries * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_color_series_set_color_scheme(vtkColorSeries* sself, int scheme) { sself->SetColorScheme(scheme); } +extern "C" int vtk_color_series_get_number_of_color_schemes(vtkColorSeries* sself) { return sself->GetNumberOfColorSchemes(); } +extern "C" int vtk_color_series_get_color_scheme(vtkColorSeries* sself) { return sself->GetColorScheme(); } +extern "C" int vtk_color_series_get_number_of_colors(vtkColorSeries* sself) { return sself->GetNumberOfColors(); } +extern "C" void vtk_color_series_set_number_of_colors(vtkColorSeries* sself, int numColors) { sself->SetNumberOfColors(numColors); } +extern "C" void vtk_color_series_remove_color(vtkColorSeries* sself, int index) { sself->RemoveColor(index); } +extern "C" void vtk_color_series_clear_colors(vtkColorSeries* sself) { sself->ClearColors(); } +extern "C" vtkNamedColors * vtkNamedColors_new () {return vtkNamedColors :: New () ;} +extern "C" void vtkNamedColors_destructor (vtkNamedColors * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_named_colors_get_number_of_colors(vtkNamedColors* sself) { return sself->GetNumberOfColors(); } +extern "C" void vtk_named_colors_reset_colors(vtkNamedColors* sself) { sself->ResetColors(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp index 9a6c9e7..f4e3506 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_computational_geometry.cpp @@ -34,75 +34,191 @@ #include // Implement declared functions -extern "C" vtkNew < vtkCardinalSpline > vtkCardinalSpline_new () {return vtkNew < vtkCardinalSpline > () ;} -extern "C" void vtkCardinalSpline_destructor (vtkNew < vtkCardinalSpline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCardinalSpline_get_ptr (vtkNew < vtkCardinalSpline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkKochanekSpline > vtkKochanekSpline_new () {return vtkNew < vtkKochanekSpline > () ;} -extern "C" void vtkKochanekSpline_destructor (vtkNew < vtkKochanekSpline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkKochanekSpline_get_ptr (vtkNew < vtkKochanekSpline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricBohemianDome > vtkParametricBohemianDome_new () {return vtkNew < vtkParametricBohemianDome > () ;} -extern "C" void vtkParametricBohemianDome_destructor (vtkNew < vtkParametricBohemianDome > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricBohemianDome_get_ptr (vtkNew < vtkParametricBohemianDome > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricBour > vtkParametricBour_new () {return vtkNew < vtkParametricBour > () ;} -extern "C" void vtkParametricBour_destructor (vtkNew < vtkParametricBour > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricBour_get_ptr (vtkNew < vtkParametricBour > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricBoy > vtkParametricBoy_new () {return vtkNew < vtkParametricBoy > () ;} -extern "C" void vtkParametricBoy_destructor (vtkNew < vtkParametricBoy > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricBoy_get_ptr (vtkNew < vtkParametricBoy > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricCatalanMinimal > vtkParametricCatalanMinimal_new () {return vtkNew < vtkParametricCatalanMinimal > () ;} -extern "C" void vtkParametricCatalanMinimal_destructor (vtkNew < vtkParametricCatalanMinimal > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricCatalanMinimal_get_ptr (vtkNew < vtkParametricCatalanMinimal > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricConicSpiral > vtkParametricConicSpiral_new () {return vtkNew < vtkParametricConicSpiral > () ;} -extern "C" void vtkParametricConicSpiral_destructor (vtkNew < vtkParametricConicSpiral > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricConicSpiral_get_ptr (vtkNew < vtkParametricConicSpiral > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricCrossCap > vtkParametricCrossCap_new () {return vtkNew < vtkParametricCrossCap > () ;} -extern "C" void vtkParametricCrossCap_destructor (vtkNew < vtkParametricCrossCap > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricCrossCap_get_ptr (vtkNew < vtkParametricCrossCap > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricDini > vtkParametricDini_new () {return vtkNew < vtkParametricDini > () ;} -extern "C" void vtkParametricDini_destructor (vtkNew < vtkParametricDini > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricDini_get_ptr (vtkNew < vtkParametricDini > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricEllipsoid > vtkParametricEllipsoid_new () {return vtkNew < vtkParametricEllipsoid > () ;} -extern "C" void vtkParametricEllipsoid_destructor (vtkNew < vtkParametricEllipsoid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricEllipsoid_get_ptr (vtkNew < vtkParametricEllipsoid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricEnneper > vtkParametricEnneper_new () {return vtkNew < vtkParametricEnneper > () ;} -extern "C" void vtkParametricEnneper_destructor (vtkNew < vtkParametricEnneper > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricEnneper_get_ptr (vtkNew < vtkParametricEnneper > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricFigure8Klein > vtkParametricFigure8Klein_new () {return vtkNew < vtkParametricFigure8Klein > () ;} -extern "C" void vtkParametricFigure8Klein_destructor (vtkNew < vtkParametricFigure8Klein > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricFigure8Klein_get_ptr (vtkNew < vtkParametricFigure8Klein > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricHenneberg > vtkParametricHenneberg_new () {return vtkNew < vtkParametricHenneberg > () ;} -extern "C" void vtkParametricHenneberg_destructor (vtkNew < vtkParametricHenneberg > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricHenneberg_get_ptr (vtkNew < vtkParametricHenneberg > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricKlein > vtkParametricKlein_new () {return vtkNew < vtkParametricKlein > () ;} -extern "C" void vtkParametricKlein_destructor (vtkNew < vtkParametricKlein > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricKlein_get_ptr (vtkNew < vtkParametricKlein > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricKuen > vtkParametricKuen_new () {return vtkNew < vtkParametricKuen > () ;} -extern "C" void vtkParametricKuen_destructor (vtkNew < vtkParametricKuen > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricKuen_get_ptr (vtkNew < vtkParametricKuen > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricMobius > vtkParametricMobius_new () {return vtkNew < vtkParametricMobius > () ;} -extern "C" void vtkParametricMobius_destructor (vtkNew < vtkParametricMobius > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricMobius_get_ptr (vtkNew < vtkParametricMobius > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricPluckerConoid > vtkParametricPluckerConoid_new () {return vtkNew < vtkParametricPluckerConoid > () ;} -extern "C" void vtkParametricPluckerConoid_destructor (vtkNew < vtkParametricPluckerConoid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricPluckerConoid_get_ptr (vtkNew < vtkParametricPluckerConoid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricPseudosphere > vtkParametricPseudosphere_new () {return vtkNew < vtkParametricPseudosphere > () ;} -extern "C" void vtkParametricPseudosphere_destructor (vtkNew < vtkParametricPseudosphere > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricPseudosphere_get_ptr (vtkNew < vtkParametricPseudosphere > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricRandomHills > vtkParametricRandomHills_new () {return vtkNew < vtkParametricRandomHills > () ;} -extern "C" void vtkParametricRandomHills_destructor (vtkNew < vtkParametricRandomHills > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricRandomHills_get_ptr (vtkNew < vtkParametricRandomHills > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricRoman > vtkParametricRoman_new () {return vtkNew < vtkParametricRoman > () ;} -extern "C" void vtkParametricRoman_destructor (vtkNew < vtkParametricRoman > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricRoman_get_ptr (vtkNew < vtkParametricRoman > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricSpline > vtkParametricSpline_new () {return vtkNew < vtkParametricSpline > () ;} -extern "C" void vtkParametricSpline_destructor (vtkNew < vtkParametricSpline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricSpline_get_ptr (vtkNew < vtkParametricSpline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricSuperEllipsoid > vtkParametricSuperEllipsoid_new () {return vtkNew < vtkParametricSuperEllipsoid > () ;} -extern "C" void vtkParametricSuperEllipsoid_destructor (vtkNew < vtkParametricSuperEllipsoid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricSuperEllipsoid_get_ptr (vtkNew < vtkParametricSuperEllipsoid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricSuperToroid > vtkParametricSuperToroid_new () {return vtkNew < vtkParametricSuperToroid > () ;} -extern "C" void vtkParametricSuperToroid_destructor (vtkNew < vtkParametricSuperToroid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricSuperToroid_get_ptr (vtkNew < vtkParametricSuperToroid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkParametricTorus > vtkParametricTorus_new () {return vtkNew < vtkParametricTorus > () ;} -extern "C" void vtkParametricTorus_destructor (vtkNew < vtkParametricTorus > sself) {sself . Reset () ; return ;} -extern "C" void * vtkParametricTorus_get_ptr (vtkNew < vtkParametricTorus > sself) {return sself . GetPointer () ;} +extern "C" vtkCardinalSpline * vtkCardinalSpline_new () {return vtkCardinalSpline :: New () ;} +extern "C" void vtkCardinalSpline_destructor (vtkCardinalSpline * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cardinal_spline_compute(vtkCardinalSpline* sself) { sself->Compute(); } +extern "C" double vtk_cardinal_spline_evaluate(vtkCardinalSpline* sself, double t) { return sself->Evaluate(t); } +extern "C" vtkKochanekSpline * vtkKochanekSpline_new () {return vtkKochanekSpline :: New () ;} +extern "C" void vtkKochanekSpline_destructor (vtkKochanekSpline * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_kochanek_spline_compute(vtkKochanekSpline* sself) { sself->Compute(); } +extern "C" double vtk_kochanek_spline_evaluate(vtkKochanekSpline* sself, double t) { return sself->Evaluate(t); } +extern "C" void vtk_kochanek_spline_set_default_bias(vtkKochanekSpline* sself, double _arg) { sself->SetDefaultBias(_arg); } +extern "C" double vtk_kochanek_spline_get_default_bias(vtkKochanekSpline* sself) { return sself->GetDefaultBias(); } +extern "C" void vtk_kochanek_spline_set_default_tension(vtkKochanekSpline* sself, double _arg) { sself->SetDefaultTension(_arg); } +extern "C" double vtk_kochanek_spline_get_default_tension(vtkKochanekSpline* sself) { return sself->GetDefaultTension(); } +extern "C" void vtk_kochanek_spline_set_default_continuity(vtkKochanekSpline* sself, double _arg) { sself->SetDefaultContinuity(_arg); } +extern "C" double vtk_kochanek_spline_get_default_continuity(vtkKochanekSpline* sself) { return sself->GetDefaultContinuity(); } +extern "C" vtkParametricBohemianDome * vtkParametricBohemianDome_new () {return vtkParametricBohemianDome :: New () ;} +extern "C" void vtkParametricBohemianDome_destructor (vtkParametricBohemianDome * sself) {sself -> Delete () ; return ;} +extern "C" double vtk_parametric_bohemian_dome_get_a(vtkParametricBohemianDome* sself) { return sself->GetA(); } +extern "C" void vtk_parametric_bohemian_dome_set_a(vtkParametricBohemianDome* sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_bohemian_dome_get_b(vtkParametricBohemianDome* sself) { return sself->GetB(); } +extern "C" void vtk_parametric_bohemian_dome_set_b(vtkParametricBohemianDome* sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_bohemian_dome_get_c(vtkParametricBohemianDome* sself) { return sself->GetC(); } +extern "C" void vtk_parametric_bohemian_dome_set_c(vtkParametricBohemianDome* sself, double _arg) { sself->SetC(_arg); } +extern "C" int vtk_parametric_bohemian_dome_get_dimension(vtkParametricBohemianDome* sself) { return sself->GetDimension(); } +extern "C" vtkParametricBour * vtkParametricBour_new () {return vtkParametricBour :: New () ;} +extern "C" void vtkParametricBour_destructor (vtkParametricBour * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_bour_get_dimension(vtkParametricBour* sself) { return sself->GetDimension(); } +extern "C" vtkParametricBoy * vtkParametricBoy_new () {return vtkParametricBoy :: New () ;} +extern "C" void vtkParametricBoy_destructor (vtkParametricBoy * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_boy_get_dimension(vtkParametricBoy* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_boy_set_z_scale(vtkParametricBoy* sself, double _arg) { sself->SetZScale(_arg); } +extern "C" double vtk_parametric_boy_get_z_scale(vtkParametricBoy* sself) { return sself->GetZScale(); } +extern "C" vtkParametricCatalanMinimal * vtkParametricCatalanMinimal_new () {return vtkParametricCatalanMinimal :: New () ;} +extern "C" void vtkParametricCatalanMinimal_destructor (vtkParametricCatalanMinimal * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_catalan_minimal_get_dimension(vtkParametricCatalanMinimal* sself) { return sself->GetDimension(); } +extern "C" vtkParametricConicSpiral * vtkParametricConicSpiral_new () {return vtkParametricConicSpiral :: New () ;} +extern "C" void vtkParametricConicSpiral_destructor (vtkParametricConicSpiral * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_conic_spiral_get_dimension(vtkParametricConicSpiral* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_conic_spiral_set_a(vtkParametricConicSpiral* sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_a(vtkParametricConicSpiral* sself) { return sself->GetA(); } +extern "C" void vtk_parametric_conic_spiral_set_b(vtkParametricConicSpiral* sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_b(vtkParametricConicSpiral* sself) { return sself->GetB(); } +extern "C" void vtk_parametric_conic_spiral_set_c(vtkParametricConicSpiral* sself, double _arg) { sself->SetC(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_c(vtkParametricConicSpiral* sself) { return sself->GetC(); } +extern "C" void vtk_parametric_conic_spiral_set_n(vtkParametricConicSpiral* sself, double _arg) { sself->SetN(_arg); } +extern "C" double vtk_parametric_conic_spiral_get_n(vtkParametricConicSpiral* sself) { return sself->GetN(); } +extern "C" vtkParametricCrossCap * vtkParametricCrossCap_new () {return vtkParametricCrossCap :: New () ;} +extern "C" void vtkParametricCrossCap_destructor (vtkParametricCrossCap * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_cross_cap_get_dimension(vtkParametricCrossCap* sself) { return sself->GetDimension(); } +extern "C" vtkParametricDini * vtkParametricDini_new () {return vtkParametricDini :: New () ;} +extern "C" void vtkParametricDini_destructor (vtkParametricDini * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_dini_get_dimension(vtkParametricDini* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_dini_set_a(vtkParametricDini* sself, double _arg) { sself->SetA(_arg); } +extern "C" double vtk_parametric_dini_get_a(vtkParametricDini* sself) { return sself->GetA(); } +extern "C" void vtk_parametric_dini_set_b(vtkParametricDini* sself, double _arg) { sself->SetB(_arg); } +extern "C" double vtk_parametric_dini_get_b(vtkParametricDini* sself) { return sself->GetB(); } +extern "C" vtkParametricEllipsoid * vtkParametricEllipsoid_new () {return vtkParametricEllipsoid :: New () ;} +extern "C" void vtkParametricEllipsoid_destructor (vtkParametricEllipsoid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_ellipsoid_get_dimension(vtkParametricEllipsoid* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_ellipsoid_set_x_radius(vtkParametricEllipsoid* sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_x_radius(vtkParametricEllipsoid* sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_ellipsoid_set_y_radius(vtkParametricEllipsoid* sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_y_radius(vtkParametricEllipsoid* sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_ellipsoid_set_z_radius(vtkParametricEllipsoid* sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_ellipsoid_get_z_radius(vtkParametricEllipsoid* sself) { return sself->GetZRadius(); } +extern "C" vtkParametricEnneper * vtkParametricEnneper_new () {return vtkParametricEnneper :: New () ;} +extern "C" void vtkParametricEnneper_destructor (vtkParametricEnneper * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_enneper_get_dimension(vtkParametricEnneper* sself) { return sself->GetDimension(); } +extern "C" vtkParametricFigure8Klein * vtkParametricFigure8Klein_new () {return vtkParametricFigure8Klein :: New () ;} +extern "C" void vtkParametricFigure8Klein_destructor (vtkParametricFigure8Klein * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_parametric_figure_8_klein_set_radius(vtkParametricFigure8Klein* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_figure_8_klein_get_radius(vtkParametricFigure8Klein* sself) { return sself->GetRadius(); } +extern "C" int vtk_parametric_figure_8_klein_get_dimension(vtkParametricFigure8Klein* sself) { return sself->GetDimension(); } +extern "C" vtkParametricHenneberg * vtkParametricHenneberg_new () {return vtkParametricHenneberg :: New () ;} +extern "C" void vtkParametricHenneberg_destructor (vtkParametricHenneberg * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_henneberg_get_dimension(vtkParametricHenneberg* sself) { return sself->GetDimension(); } +extern "C" vtkParametricKlein * vtkParametricKlein_new () {return vtkParametricKlein :: New () ;} +extern "C" void vtkParametricKlein_destructor (vtkParametricKlein * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_klein_get_dimension(vtkParametricKlein* sself) { return sself->GetDimension(); } +extern "C" vtkParametricKuen * vtkParametricKuen_new () {return vtkParametricKuen :: New () ;} +extern "C" void vtkParametricKuen_destructor (vtkParametricKuen * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_kuen_get_dimension(vtkParametricKuen* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_kuen_set_delta_v_0(vtkParametricKuen* sself, double _arg) { sself->SetDeltaV0(_arg); } +extern "C" double vtk_parametric_kuen_get_delta_v_0(vtkParametricKuen* sself) { return sself->GetDeltaV0(); } +extern "C" vtkParametricMobius * vtkParametricMobius_new () {return vtkParametricMobius :: New () ;} +extern "C" void vtkParametricMobius_destructor (vtkParametricMobius * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_parametric_mobius_set_radius(vtkParametricMobius* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_mobius_get_radius(vtkParametricMobius* sself) { return sself->GetRadius(); } +extern "C" int vtk_parametric_mobius_get_dimension(vtkParametricMobius* sself) { return sself->GetDimension(); } +extern "C" vtkParametricPluckerConoid * vtkParametricPluckerConoid_new () {return vtkParametricPluckerConoid :: New () ;} +extern "C" void vtkParametricPluckerConoid_destructor (vtkParametricPluckerConoid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_plucker_conoid_get_n(vtkParametricPluckerConoid* sself) { return sself->GetN(); } +extern "C" void vtk_parametric_plucker_conoid_set_n(vtkParametricPluckerConoid* sself, int _arg) { sself->SetN(_arg); } +extern "C" int vtk_parametric_plucker_conoid_get_dimension(vtkParametricPluckerConoid* sself) { return sself->GetDimension(); } +extern "C" vtkParametricPseudosphere * vtkParametricPseudosphere_new () {return vtkParametricPseudosphere :: New () ;} +extern "C" void vtkParametricPseudosphere_destructor (vtkParametricPseudosphere * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_pseudosphere_get_dimension(vtkParametricPseudosphere* sself) { return sself->GetDimension(); } +extern "C" vtkParametricRandomHills * vtkParametricRandomHills_new () {return vtkParametricRandomHills :: New () ;} +extern "C" void vtkParametricRandomHills_destructor (vtkParametricRandomHills * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_random_hills_get_dimension(vtkParametricRandomHills* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_random_hills_set_number_of_hills(vtkParametricRandomHills* sself, int _arg) { sself->SetNumberOfHills(_arg); } +extern "C" int vtk_parametric_random_hills_get_number_of_hills(vtkParametricRandomHills* sself) { return sself->GetNumberOfHills(); } +extern "C" void vtk_parametric_random_hills_set_hill_x_variance(vtkParametricRandomHills* sself, double _arg) { sself->SetHillXVariance(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_x_variance(vtkParametricRandomHills* sself) { return sself->GetHillXVariance(); } +extern "C" void vtk_parametric_random_hills_set_hill_y_variance(vtkParametricRandomHills* sself, double _arg) { sself->SetHillYVariance(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_y_variance(vtkParametricRandomHills* sself) { return sself->GetHillYVariance(); } +extern "C" void vtk_parametric_random_hills_set_hill_amplitude(vtkParametricRandomHills* sself, double _arg) { sself->SetHillAmplitude(_arg); } +extern "C" double vtk_parametric_random_hills_get_hill_amplitude(vtkParametricRandomHills* sself) { return sself->GetHillAmplitude(); } +extern "C" void vtk_parametric_random_hills_set_random_seed(vtkParametricRandomHills* sself, int _arg) { sself->SetRandomSeed(_arg); } +extern "C" int vtk_parametric_random_hills_get_random_seed(vtkParametricRandomHills* sself) { return sself->GetRandomSeed(); } +extern "C" void vtk_parametric_random_hills_set_allow_random_generation(vtkParametricRandomHills* sself, int _arg) { sself->SetAllowRandomGeneration(_arg); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_min_value(vtkParametricRandomHills* sself) { return sself->GetAllowRandomGenerationMinValue(); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation_max_value(vtkParametricRandomHills* sself) { return sself->GetAllowRandomGenerationMaxValue(); } +extern "C" int vtk_parametric_random_hills_get_allow_random_generation(vtkParametricRandomHills* sself) { return sself->GetAllowRandomGeneration(); } +extern "C" void vtk_parametric_random_hills_allow_random_generation_on(vtkParametricRandomHills* sself) { sself->AllowRandomGenerationOn(); } +extern "C" void vtk_parametric_random_hills_allow_random_generation_off(vtkParametricRandomHills* sself) { sself->AllowRandomGenerationOff(); } +extern "C" void vtk_parametric_random_hills_set_x_variance_scale_factor(vtkParametricRandomHills* sself, double _arg) { sself->SetXVarianceScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_x_variance_scale_factor(vtkParametricRandomHills* sself) { return sself->GetXVarianceScaleFactor(); } +extern "C" void vtk_parametric_random_hills_set_y_variance_scale_factor(vtkParametricRandomHills* sself, double _arg) { sself->SetYVarianceScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_y_variance_scale_factor(vtkParametricRandomHills* sself) { return sself->GetYVarianceScaleFactor(); } +extern "C" void vtk_parametric_random_hills_set_amplitude_scale_factor(vtkParametricRandomHills* sself, double _arg) { sself->SetAmplitudeScaleFactor(_arg); } +extern "C" double vtk_parametric_random_hills_get_amplitude_scale_factor(vtkParametricRandomHills* sself) { return sself->GetAmplitudeScaleFactor(); } +extern "C" vtkParametricRoman * vtkParametricRoman_new () {return vtkParametricRoman :: New () ;} +extern "C" void vtkParametricRoman_destructor (vtkParametricRoman * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_roman_get_dimension(vtkParametricRoman* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_roman_set_radius(vtkParametricRoman* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_parametric_roman_get_radius(vtkParametricRoman* sself) { return sself->GetRadius(); } +extern "C" vtkParametricSpline * vtkParametricSpline_new () {return vtkParametricSpline :: New () ;} +extern "C" void vtkParametricSpline_destructor (vtkParametricSpline * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_spline_get_dimension(vtkParametricSpline* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_spline_set_number_of_points(vtkParametricSpline* sself, long long numPts) { sself->SetNumberOfPoints(numPts); } +extern "C" void vtk_parametric_spline_set_point(vtkParametricSpline* sself, long long index, double x, double y, double z) { sself->SetPoint(index, x, y, z); } +extern "C" void vtk_parametric_spline_set_closed(vtkParametricSpline* sself, int _arg) { sself->SetClosed(_arg); } +extern "C" int vtk_parametric_spline_get_closed(vtkParametricSpline* sself) { return sself->GetClosed(); } +extern "C" void vtk_parametric_spline_closed_on(vtkParametricSpline* sself) { sself->ClosedOn(); } +extern "C" void vtk_parametric_spline_closed_off(vtkParametricSpline* sself) { sself->ClosedOff(); } +extern "C" void vtk_parametric_spline_set_parameterize_by_length(vtkParametricSpline* sself, int _arg) { sself->SetParameterizeByLength(_arg); } +extern "C" int vtk_parametric_spline_get_parameterize_by_length(vtkParametricSpline* sself) { return sself->GetParameterizeByLength(); } +extern "C" void vtk_parametric_spline_parameterize_by_length_on(vtkParametricSpline* sself) { sself->ParameterizeByLengthOn(); } +extern "C" void vtk_parametric_spline_parameterize_by_length_off(vtkParametricSpline* sself) { sself->ParameterizeByLengthOff(); } +extern "C" void vtk_parametric_spline_set_left_constraint(vtkParametricSpline* sself, int _arg) { sself->SetLeftConstraint(_arg); } +extern "C" int vtk_parametric_spline_get_left_constraint_min_value(vtkParametricSpline* sself) { return sself->GetLeftConstraintMinValue(); } +extern "C" int vtk_parametric_spline_get_left_constraint_max_value(vtkParametricSpline* sself) { return sself->GetLeftConstraintMaxValue(); } +extern "C" int vtk_parametric_spline_get_left_constraint(vtkParametricSpline* sself) { return sself->GetLeftConstraint(); } +extern "C" void vtk_parametric_spline_set_right_constraint(vtkParametricSpline* sself, int _arg) { sself->SetRightConstraint(_arg); } +extern "C" int vtk_parametric_spline_get_right_constraint_min_value(vtkParametricSpline* sself) { return sself->GetRightConstraintMinValue(); } +extern "C" int vtk_parametric_spline_get_right_constraint_max_value(vtkParametricSpline* sself) { return sself->GetRightConstraintMaxValue(); } +extern "C" int vtk_parametric_spline_get_right_constraint(vtkParametricSpline* sself) { return sself->GetRightConstraint(); } +extern "C" void vtk_parametric_spline_set_left_value(vtkParametricSpline* sself, double _arg) { sself->SetLeftValue(_arg); } +extern "C" double vtk_parametric_spline_get_left_value(vtkParametricSpline* sself) { return sself->GetLeftValue(); } +extern "C" void vtk_parametric_spline_set_right_value(vtkParametricSpline* sself, double _arg) { sself->SetRightValue(_arg); } +extern "C" double vtk_parametric_spline_get_right_value(vtkParametricSpline* sself) { return sself->GetRightValue(); } +extern "C" vtkParametricSuperEllipsoid * vtkParametricSuperEllipsoid_new () {return vtkParametricSuperEllipsoid :: New () ;} +extern "C" void vtkParametricSuperEllipsoid_destructor (vtkParametricSuperEllipsoid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_super_ellipsoid_get_dimension(vtkParametricSuperEllipsoid* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_super_ellipsoid_set_x_radius(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_x_radius(vtkParametricSuperEllipsoid* sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_y_radius(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_y_radius(vtkParametricSuperEllipsoid* sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_z_radius(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_z_radius(vtkParametricSuperEllipsoid* sself) { return sself->GetZRadius(); } +extern "C" void vtk_parametric_super_ellipsoid_set_n_1(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetN1(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_n_1(vtkParametricSuperEllipsoid* sself) { return sself->GetN1(); } +extern "C" void vtk_parametric_super_ellipsoid_set_n_2(vtkParametricSuperEllipsoid* sself, double _arg) { sself->SetN2(_arg); } +extern "C" double vtk_parametric_super_ellipsoid_get_n_2(vtkParametricSuperEllipsoid* sself) { return sself->GetN2(); } +extern "C" vtkParametricSuperToroid * vtkParametricSuperToroid_new () {return vtkParametricSuperToroid :: New () ;} +extern "C" void vtkParametricSuperToroid_destructor (vtkParametricSuperToroid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_parametric_super_toroid_get_dimension(vtkParametricSuperToroid* sself) { return sself->GetDimension(); } +extern "C" void vtk_parametric_super_toroid_set_ring_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetRingRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_ring_radius(vtkParametricSuperToroid* sself) { return sself->GetRingRadius(); } +extern "C" void vtk_parametric_super_toroid_set_cross_section_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetCrossSectionRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_cross_section_radius(vtkParametricSuperToroid* sself) { return sself->GetCrossSectionRadius(); } +extern "C" void vtk_parametric_super_toroid_set_x_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetXRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_x_radius(vtkParametricSuperToroid* sself) { return sself->GetXRadius(); } +extern "C" void vtk_parametric_super_toroid_set_y_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetYRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_y_radius(vtkParametricSuperToroid* sself) { return sself->GetYRadius(); } +extern "C" void vtk_parametric_super_toroid_set_z_radius(vtkParametricSuperToroid* sself, double _arg) { sself->SetZRadius(_arg); } +extern "C" double vtk_parametric_super_toroid_get_z_radius(vtkParametricSuperToroid* sself) { return sself->GetZRadius(); } +extern "C" void vtk_parametric_super_toroid_set_n_1(vtkParametricSuperToroid* sself, double _arg) { sself->SetN1(_arg); } +extern "C" double vtk_parametric_super_toroid_get_n_1(vtkParametricSuperToroid* sself) { return sself->GetN1(); } +extern "C" void vtk_parametric_super_toroid_set_n_2(vtkParametricSuperToroid* sself, double _arg) { sself->SetN2(_arg); } +extern "C" double vtk_parametric_super_toroid_get_n_2(vtkParametricSuperToroid* sself) { return sself->GetN2(); } +extern "C" vtkParametricTorus * vtkParametricTorus_new () {return vtkParametricTorus :: New () ;} +extern "C" void vtkParametricTorus_destructor (vtkParametricTorus * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_parametric_torus_set_ring_radius(vtkParametricTorus* sself, double _arg) { sself->SetRingRadius(_arg); } +extern "C" double vtk_parametric_torus_get_ring_radius(vtkParametricTorus* sself) { return sself->GetRingRadius(); } +extern "C" void vtk_parametric_torus_set_cross_section_radius(vtkParametricTorus* sself, double _arg) { sself->SetCrossSectionRadius(_arg); } +extern "C" double vtk_parametric_torus_get_cross_section_radius(vtkParametricTorus* sself) { return sself->GetCrossSectionRadius(); } +extern "C" int vtk_parametric_torus_get_dimension(vtkParametricTorus* sself) { return sself->GetDimension(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp index bb509e5..6d165ec 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_core.cpp @@ -19,7 +19,6 @@ #include #include #include -#include #include #include #include @@ -148,6 +147,8 @@ #include #include #include +#include +#include #include #include #include @@ -164,228 +165,735 @@ #include // Implement declared functions -extern "C" vtkNew < vtkAnimationCue > vtkAnimationCue_new () {return vtkNew < vtkAnimationCue > () ;} -extern "C" void vtkAnimationCue_destructor (vtkNew < vtkAnimationCue > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnimationCue_get_ptr (vtkNew < vtkAnimationCue > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkArchiver > vtkArchiver_new () {return vtkNew < vtkArchiver > () ;} -extern "C" void vtkArchiver_destructor (vtkNew < vtkArchiver > sself) {sself . Reset () ; return ;} -extern "C" void * vtkArchiver_get_ptr (vtkNew < vtkArchiver > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBitArray > vtkBitArray_new () {return vtkNew < vtkBitArray > () ;} -extern "C" void vtkBitArray_destructor (vtkNew < vtkBitArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBitArray_get_ptr (vtkNew < vtkBitArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBitArrayIterator > vtkBitArrayIterator_new () {return vtkNew < vtkBitArrayIterator > () ;} -extern "C" void vtkBitArrayIterator_destructor (vtkNew < vtkBitArrayIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBitArrayIterator_get_ptr (vtkNew < vtkBitArrayIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBoxMuellerRandomSequence > vtkBoxMuellerRandomSequence_new () {return vtkNew < vtkBoxMuellerRandomSequence > () ;} -extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkNew < vtkBoxMuellerRandomSequence > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBoxMuellerRandomSequence_get_ptr (vtkNew < vtkBoxMuellerRandomSequence > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkByteSwap > vtkByteSwap_new () {return vtkNew < vtkByteSwap > () ;} -extern "C" void vtkByteSwap_destructor (vtkNew < vtkByteSwap > sself) {sself . Reset () ; return ;} -extern "C" void * vtkByteSwap_get_ptr (vtkNew < vtkByteSwap > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCallbackCommand > vtkCallbackCommand_new () {return vtkNew < vtkCallbackCommand > () ;} -extern "C" void vtkCallbackCommand_destructor (vtkNew < vtkCallbackCommand > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCallbackCommand_get_ptr (vtkNew < vtkCallbackCommand > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCharArray > vtkCharArray_new () {return vtkNew < vtkCharArray > () ;} -extern "C" void vtkCharArray_destructor (vtkNew < vtkCharArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCharArray_get_ptr (vtkNew < vtkCharArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCollection > vtkCollection_new () {return vtkNew < vtkCollection > () ;} -extern "C" void vtkCollection_destructor (vtkNew < vtkCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCollection_get_ptr (vtkNew < vtkCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCollectionIterator > vtkCollectionIterator_new () {return vtkNew < vtkCollectionIterator > () ;} -extern "C" void vtkCollectionIterator_destructor (vtkNew < vtkCollectionIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCollectionIterator_get_ptr (vtkNew < vtkCollectionIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCriticalSection > vtkCriticalSection_new () {return vtkNew < vtkCriticalSection > () ;} -extern "C" void vtkCriticalSection_destructor (vtkNew < vtkCriticalSection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCriticalSection_get_ptr (vtkNew < vtkCriticalSection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataArrayCollection > vtkDataArrayCollection_new () {return vtkNew < vtkDataArrayCollection > () ;} -extern "C" void vtkDataArrayCollection_destructor (vtkNew < vtkDataArrayCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataArrayCollection_get_ptr (vtkNew < vtkDataArrayCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataArrayCollectionIterator > vtkDataArrayCollectionIterator_new () {return vtkNew < vtkDataArrayCollectionIterator > () ;} -extern "C" void vtkDataArrayCollectionIterator_destructor (vtkNew < vtkDataArrayCollectionIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataArrayCollectionIterator_get_ptr (vtkNew < vtkDataArrayCollectionIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataArraySelection > vtkDataArraySelection_new () {return vtkNew < vtkDataArraySelection > () ;} -extern "C" void vtkDataArraySelection_destructor (vtkNew < vtkDataArraySelection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataArraySelection_get_ptr (vtkNew < vtkDataArraySelection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDebugLeaks > vtkDebugLeaks_new () {return vtkNew < vtkDebugLeaks > () ;} -extern "C" void vtkDebugLeaks_destructor (vtkNew < vtkDebugLeaks > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDebugLeaks_get_ptr (vtkNew < vtkDebugLeaks > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDoubleArray > vtkDoubleArray_new () {return vtkNew < vtkDoubleArray > () ;} -extern "C" void vtkDoubleArray_destructor (vtkNew < vtkDoubleArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDoubleArray_get_ptr (vtkNew < vtkDoubleArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDynamicLoader > vtkDynamicLoader_new () {return vtkNew < vtkDynamicLoader > () ;} -extern "C" void vtkDynamicLoader_destructor (vtkNew < vtkDynamicLoader > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDynamicLoader_get_ptr (vtkNew < vtkDynamicLoader > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEventDataDevice3D > vtkEventDataDevice3D_new () {return vtkNew < vtkEventDataDevice3D > () ;} -extern "C" void vtkEventDataDevice3D_destructor (vtkNew < vtkEventDataDevice3D > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEventDataDevice3D_get_ptr (vtkNew < vtkEventDataDevice3D > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEventDataForDevice > vtkEventDataForDevice_new () {return vtkNew < vtkEventDataForDevice > () ;} -extern "C" void vtkEventDataForDevice_destructor (vtkNew < vtkEventDataForDevice > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEventDataForDevice_get_ptr (vtkNew < vtkEventDataForDevice > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEventForwarderCommand > vtkEventForwarderCommand_new () {return vtkNew < vtkEventForwarderCommand > () ;} -extern "C" void vtkEventForwarderCommand_destructor (vtkNew < vtkEventForwarderCommand > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEventForwarderCommand_get_ptr (vtkNew < vtkEventForwarderCommand > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkFileOutputWindow > vtkFileOutputWindow_new () {return vtkNew < vtkFileOutputWindow > () ;} -extern "C" void vtkFileOutputWindow_destructor (vtkNew < vtkFileOutputWindow > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFileOutputWindow_get_ptr (vtkNew < vtkFileOutputWindow > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkFloatArray > vtkFloatArray_new () {return vtkNew < vtkFloatArray > () ;} -extern "C" void vtkFloatArray_destructor (vtkNew < vtkFloatArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFloatArray_get_ptr (vtkNew < vtkFloatArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGarbageCollector > vtkGarbageCollector_new () {return vtkNew < vtkGarbageCollector > () ;} -extern "C" void vtkGarbageCollector_destructor (vtkNew < vtkGarbageCollector > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGarbageCollector_get_ptr (vtkNew < vtkGarbageCollector > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkIdList > vtkIdList_new () {return vtkNew < vtkIdList > () ;} -extern "C" void vtkIdList_destructor (vtkNew < vtkIdList > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIdList_get_ptr (vtkNew < vtkIdList > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkIdListCollection > vtkIdListCollection_new () {return vtkNew < vtkIdListCollection > () ;} -extern "C" void vtkIdListCollection_destructor (vtkNew < vtkIdListCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIdListCollection_get_ptr (vtkNew < vtkIdListCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkIdTypeArray > vtkIdTypeArray_new () {return vtkNew < vtkIdTypeArray > () ;} -extern "C" void vtkIdTypeArray_destructor (vtkNew < vtkIdTypeArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIdTypeArray_get_ptr (vtkNew < vtkIdTypeArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkInformation > vtkInformation_new () {return vtkNew < vtkInformation > () ;} -extern "C" void vtkInformation_destructor (vtkNew < vtkInformation > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInformation_get_ptr (vtkNew < vtkInformation > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkInformationIterator > vtkInformationIterator_new () {return vtkNew < vtkInformationIterator > () ;} -extern "C" void vtkInformationIterator_destructor (vtkNew < vtkInformationIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInformationIterator_get_ptr (vtkNew < vtkInformationIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkInformationKeyLookup > vtkInformationKeyLookup_new () {return vtkNew < vtkInformationKeyLookup > () ;} -extern "C" void vtkInformationKeyLookup_destructor (vtkNew < vtkInformationKeyLookup > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInformationKeyLookup_get_ptr (vtkNew < vtkInformationKeyLookup > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkInformationVector > vtkInformationVector_new () {return vtkNew < vtkInformationVector > () ;} -extern "C" void vtkInformationVector_destructor (vtkNew < vtkInformationVector > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInformationVector_get_ptr (vtkNew < vtkInformationVector > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkIntArray > vtkIntArray_new () {return vtkNew < vtkIntArray > () ;} -extern "C" void vtkIntArray_destructor (vtkNew < vtkIntArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIntArray_get_ptr (vtkNew < vtkIntArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLongArray > vtkLongArray_new () {return vtkNew < vtkLongArray > () ;} -extern "C" void vtkLongArray_destructor (vtkNew < vtkLongArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLongArray_get_ptr (vtkNew < vtkLongArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLongLongArray > vtkLongLongArray_new () {return vtkNew < vtkLongLongArray > () ;} -extern "C" void vtkLongLongArray_destructor (vtkNew < vtkLongLongArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLongLongArray_get_ptr (vtkNew < vtkLongLongArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLookupTable > vtkLookupTable_new () {return vtkNew < vtkLookupTable > () ;} -extern "C" void vtkLookupTable_destructor (vtkNew < vtkLookupTable > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLookupTable_get_ptr (vtkNew < vtkLookupTable > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMath > vtkMath_new () {return vtkNew < vtkMath > () ;} -extern "C" void vtkMath_destructor (vtkNew < vtkMath > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMath_get_ptr (vtkNew < vtkMath > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMersenneTwister > vtkMersenneTwister_new () {return vtkNew < vtkMersenneTwister > () ;} -extern "C" void vtkMersenneTwister_destructor (vtkNew < vtkMersenneTwister > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMersenneTwister_get_ptr (vtkNew < vtkMersenneTwister > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMinimalStandardRandomSequence > vtkMinimalStandardRandomSequence_new () {return vtkNew < vtkMinimalStandardRandomSequence > () ;} -extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkNew < vtkMinimalStandardRandomSequence > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMinimalStandardRandomSequence_get_ptr (vtkNew < vtkMinimalStandardRandomSequence > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMultiThreader > vtkMultiThreader_new () {return vtkNew < vtkMultiThreader > () ;} -extern "C" void vtkMultiThreader_destructor (vtkNew < vtkMultiThreader > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiThreader_get_ptr (vtkNew < vtkMultiThreader > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkObject > vtkObject_new () {return vtkNew < vtkObject > () ;} -extern "C" void vtkObject_destructor (vtkNew < vtkObject > sself) {sself . Reset () ; return ;} -extern "C" void * vtkObject_get_ptr (vtkNew < vtkObject > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkObjectFactoryCollection > vtkObjectFactoryCollection_new () {return vtkNew < vtkObjectFactoryCollection > () ;} -extern "C" void vtkObjectFactoryCollection_destructor (vtkNew < vtkObjectFactoryCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkObjectFactoryCollection_get_ptr (vtkNew < vtkObjectFactoryCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOldStyleCallbackCommand > vtkOldStyleCallbackCommand_new () {return vtkNew < vtkOldStyleCallbackCommand > () ;} -extern "C" void vtkOldStyleCallbackCommand_destructor (vtkNew < vtkOldStyleCallbackCommand > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOldStyleCallbackCommand_get_ptr (vtkNew < vtkOldStyleCallbackCommand > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOutputWindow > vtkOutputWindow_new () {return vtkNew < vtkOutputWindow > () ;} -extern "C" void vtkOutputWindow_destructor (vtkNew < vtkOutputWindow > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOutputWindow_get_ptr (vtkNew < vtkOutputWindow > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOverrideInformationCollection > vtkOverrideInformationCollection_new () {return vtkNew < vtkOverrideInformationCollection > () ;} -extern "C" void vtkOverrideInformationCollection_destructor (vtkNew < vtkOverrideInformationCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOverrideInformationCollection_get_ptr (vtkNew < vtkOverrideInformationCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPoints > vtkPoints_new () {return vtkNew < vtkPoints > () ;} -extern "C" void vtkPoints_destructor (vtkNew < vtkPoints > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPoints_get_ptr (vtkNew < vtkPoints > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPoints2D > vtkPoints2D_new () {return vtkNew < vtkPoints2D > () ;} -extern "C" void vtkPoints2D_destructor (vtkNew < vtkPoints2D > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPoints2D_get_ptr (vtkNew < vtkPoints2D > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPriorityQueue > vtkPriorityQueue_new () {return vtkNew < vtkPriorityQueue > () ;} -extern "C" void vtkPriorityQueue_destructor (vtkNew < vtkPriorityQueue > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPriorityQueue_get_ptr (vtkNew < vtkPriorityQueue > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkRandomPool > vtkRandomPool_new () {return vtkNew < vtkRandomPool > () ;} -extern "C" void vtkRandomPool_destructor (vtkNew < vtkRandomPool > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRandomPool_get_ptr (vtkNew < vtkRandomPool > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkReferenceCount > vtkReferenceCount_new () {return vtkNew < vtkReferenceCount > () ;} -extern "C" void vtkReferenceCount_destructor (vtkNew < vtkReferenceCount > sself) {sself . Reset () ; return ;} -extern "C" void * vtkReferenceCount_get_ptr (vtkNew < vtkReferenceCount > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkScalarsToColors > vtkScalarsToColors_new () {return vtkNew < vtkScalarsToColors > () ;} -extern "C" void vtkScalarsToColors_destructor (vtkNew < vtkScalarsToColors > sself) {sself . Reset () ; return ;} -extern "C" void * vtkScalarsToColors_get_ptr (vtkNew < vtkScalarsToColors > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkShortArray > vtkShortArray_new () {return vtkNew < vtkShortArray > () ;} -extern "C" void vtkShortArray_destructor (vtkNew < vtkShortArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkShortArray_get_ptr (vtkNew < vtkShortArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSignedCharArray > vtkSignedCharArray_new () {return vtkNew < vtkSignedCharArray > () ;} -extern "C" void vtkSignedCharArray_destructor (vtkNew < vtkSignedCharArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSignedCharArray_get_ptr (vtkNew < vtkSignedCharArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSortDataArray > vtkSortDataArray_new () {return vtkNew < vtkSortDataArray > () ;} -extern "C" void vtkSortDataArray_destructor (vtkNew < vtkSortDataArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSortDataArray_get_ptr (vtkNew < vtkSortDataArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStringArray > vtkStringArray_new () {return vtkNew < vtkStringArray > () ;} -extern "C" void vtkStringArray_destructor (vtkNew < vtkStringArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStringArray_get_ptr (vtkNew < vtkStringArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStringOutputWindow > vtkStringOutputWindow_new () {return vtkNew < vtkStringOutputWindow > () ;} -extern "C" void vtkStringOutputWindow_destructor (vtkNew < vtkStringOutputWindow > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStringOutputWindow_get_ptr (vtkNew < vtkStringOutputWindow > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTimePointUtility > vtkTimePointUtility_new () {return vtkNew < vtkTimePointUtility > () ;} -extern "C" void vtkTimePointUtility_destructor (vtkNew < vtkTimePointUtility > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTimePointUtility_get_ptr (vtkNew < vtkTimePointUtility > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeFloat32Array > vtkTypeFloat32Array_new () {return vtkNew < vtkTypeFloat32Array > () ;} -extern "C" void vtkTypeFloat32Array_destructor (vtkNew < vtkTypeFloat32Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeFloat32Array_get_ptr (vtkNew < vtkTypeFloat32Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeFloat64Array > vtkTypeFloat64Array_new () {return vtkNew < vtkTypeFloat64Array > () ;} -extern "C" void vtkTypeFloat64Array_destructor (vtkNew < vtkTypeFloat64Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeFloat64Array_get_ptr (vtkNew < vtkTypeFloat64Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeInt16Array > vtkTypeInt16Array_new () {return vtkNew < vtkTypeInt16Array > () ;} -extern "C" void vtkTypeInt16Array_destructor (vtkNew < vtkTypeInt16Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeInt16Array_get_ptr (vtkNew < vtkTypeInt16Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeInt32Array > vtkTypeInt32Array_new () {return vtkNew < vtkTypeInt32Array > () ;} -extern "C" void vtkTypeInt32Array_destructor (vtkNew < vtkTypeInt32Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeInt32Array_get_ptr (vtkNew < vtkTypeInt32Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeInt64Array > vtkTypeInt64Array_new () {return vtkNew < vtkTypeInt64Array > () ;} -extern "C" void vtkTypeInt64Array_destructor (vtkNew < vtkTypeInt64Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeInt64Array_get_ptr (vtkNew < vtkTypeInt64Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeInt8Array > vtkTypeInt8Array_new () {return vtkNew < vtkTypeInt8Array > () ;} -extern "C" void vtkTypeInt8Array_destructor (vtkNew < vtkTypeInt8Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeInt8Array_get_ptr (vtkNew < vtkTypeInt8Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeUInt16Array > vtkTypeUInt16Array_new () {return vtkNew < vtkTypeUInt16Array > () ;} -extern "C" void vtkTypeUInt16Array_destructor (vtkNew < vtkTypeUInt16Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeUInt16Array_get_ptr (vtkNew < vtkTypeUInt16Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeUInt32Array > vtkTypeUInt32Array_new () {return vtkNew < vtkTypeUInt32Array > () ;} -extern "C" void vtkTypeUInt32Array_destructor (vtkNew < vtkTypeUInt32Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeUInt32Array_get_ptr (vtkNew < vtkTypeUInt32Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeUInt64Array > vtkTypeUInt64Array_new () {return vtkNew < vtkTypeUInt64Array > () ;} -extern "C" void vtkTypeUInt64Array_destructor (vtkNew < vtkTypeUInt64Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeUInt64Array_get_ptr (vtkNew < vtkTypeUInt64Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTypeUInt8Array > vtkTypeUInt8Array_new () {return vtkNew < vtkTypeUInt8Array > () ;} -extern "C" void vtkTypeUInt8Array_destructor (vtkNew < vtkTypeUInt8Array > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTypeUInt8Array_get_ptr (vtkNew < vtkTypeUInt8Array > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnsignedCharArray > vtkUnsignedCharArray_new () {return vtkNew < vtkUnsignedCharArray > () ;} -extern "C" void vtkUnsignedCharArray_destructor (vtkNew < vtkUnsignedCharArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedCharArray_get_ptr (vtkNew < vtkUnsignedCharArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnsignedIntArray > vtkUnsignedIntArray_new () {return vtkNew < vtkUnsignedIntArray > () ;} -extern "C" void vtkUnsignedIntArray_destructor (vtkNew < vtkUnsignedIntArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedIntArray_get_ptr (vtkNew < vtkUnsignedIntArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnsignedLongArray > vtkUnsignedLongArray_new () {return vtkNew < vtkUnsignedLongArray > () ;} -extern "C" void vtkUnsignedLongArray_destructor (vtkNew < vtkUnsignedLongArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedLongArray_get_ptr (vtkNew < vtkUnsignedLongArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnsignedLongLongArray > vtkUnsignedLongLongArray_new () {return vtkNew < vtkUnsignedLongLongArray > () ;} -extern "C" void vtkUnsignedLongLongArray_destructor (vtkNew < vtkUnsignedLongLongArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedLongLongArray_get_ptr (vtkNew < vtkUnsignedLongLongArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnsignedShortArray > vtkUnsignedShortArray_new () {return vtkNew < vtkUnsignedShortArray > () ;} -extern "C" void vtkUnsignedShortArray_destructor (vtkNew < vtkUnsignedShortArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnsignedShortArray_get_ptr (vtkNew < vtkUnsignedShortArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkVariantArray > vtkVariantArray_new () {return vtkNew < vtkVariantArray > () ;} -extern "C" void vtkVariantArray_destructor (vtkNew < vtkVariantArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVariantArray_get_ptr (vtkNew < vtkVariantArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkVersion > vtkVersion_new () {return vtkNew < vtkVersion > () ;} -extern "C" void vtkVersion_destructor (vtkNew < vtkVersion > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVersion_get_ptr (vtkNew < vtkVersion > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkVoidArray > vtkVoidArray_new () {return vtkNew < vtkVoidArray > () ;} -extern "C" void vtkVoidArray_destructor (vtkNew < vtkVoidArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVoidArray_get_ptr (vtkNew < vtkVoidArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkWeakReference > vtkWeakReference_new () {return vtkNew < vtkWeakReference > () ;} -extern "C" void vtkWeakReference_destructor (vtkNew < vtkWeakReference > sself) {sself . Reset () ; return ;} -extern "C" void * vtkWeakReference_get_ptr (vtkNew < vtkWeakReference > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkXMLFileOutputWindow > vtkXMLFileOutputWindow_new () {return vtkNew < vtkXMLFileOutputWindow > () ;} -extern "C" void vtkXMLFileOutputWindow_destructor (vtkNew < vtkXMLFileOutputWindow > sself) {sself . Reset () ; return ;} -extern "C" void * vtkXMLFileOutputWindow_get_ptr (vtkNew < vtkXMLFileOutputWindow > sself) {return sself . GetPointer () ;} +extern "C" vtkAnimationCue * vtkAnimationCue_new () {return vtkAnimationCue :: New () ;} +extern "C" void vtkAnimationCue_destructor (vtkAnimationCue * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_animation_cue_set_time_mode(vtkAnimationCue* sself, int mode) { sself->SetTimeMode(mode); } +extern "C" int vtk_animation_cue_get_time_mode(vtkAnimationCue* sself) { return sself->GetTimeMode(); } +extern "C" void vtk_animation_cue_set_time_mode_to_relative(vtkAnimationCue* sself) { sself->SetTimeModeToRelative(); } +extern "C" void vtk_animation_cue_set_time_mode_to_normalized(vtkAnimationCue* sself) { sself->SetTimeModeToNormalized(); } +extern "C" void vtk_animation_cue_set_start_time(vtkAnimationCue* sself, double _arg) { sself->SetStartTime(_arg); } +extern "C" double vtk_animation_cue_get_start_time(vtkAnimationCue* sself) { return sself->GetStartTime(); } +extern "C" void vtk_animation_cue_set_end_time(vtkAnimationCue* sself, double _arg) { sself->SetEndTime(_arg); } +extern "C" double vtk_animation_cue_get_end_time(vtkAnimationCue* sself) { return sself->GetEndTime(); } +extern "C" void vtk_animation_cue_tick(vtkAnimationCue* sself, double currenttime, double deltatime, double clocktime) { sself->Tick(currenttime, deltatime, clocktime); } +extern "C" void vtk_animation_cue_initialize(vtkAnimationCue* sself) { sself->Initialize(); } +extern "C" void vtk_animation_cue_finalize(vtkAnimationCue* sself) { sself->Finalize(); } +extern "C" double vtk_animation_cue_get_animation_time(vtkAnimationCue* sself) { return sself->GetAnimationTime(); } +extern "C" double vtk_animation_cue_get_delta_time(vtkAnimationCue* sself) { return sself->GetDeltaTime(); } +extern "C" double vtk_animation_cue_get_clock_time(vtkAnimationCue* sself) { return sself->GetClockTime(); } +extern "C" vtkArchiver * vtkArchiver_new () {return vtkArchiver :: New () ;} +extern "C" void vtkArchiver_destructor (vtkArchiver * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_archiver_set_archive_name(vtkArchiver* sself, const char* _arg) { sself->SetArchiveName(_arg); } +extern "C" void vtk_archiver_open_archive(vtkArchiver* sself) { sself->OpenArchive(); } +extern "C" void vtk_archiver_close_archive(vtkArchiver* sself) { sself->CloseArchive(); } +extern "C" void vtk_archiver_insert_into_archive(vtkArchiver* sself, const char*& relativePath, const char* data, size_t size) { sself->InsertIntoArchive(relativePath, data, size); } +extern "C" bool vtk_archiver_contains(vtkArchiver* sself, const char*& relativePath) { return sself->Contains(relativePath); } +extern "C" vtkBitArray * vtkBitArray_new () {return vtkBitArray :: New () ;} +extern "C" void vtkBitArray_destructor (vtkBitArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bit_array_allocate(vtkBitArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_bit_array_initialize(vtkBitArray* sself) { sself->Initialize(); } +extern "C" int vtk_bit_array_get_data_type(vtkBitArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_bit_array_get_data_type_size(vtkBitArray* sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_bit_array_set_number_of_tuples(vtkBitArray* sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" bool vtk_bit_array_set_number_of_values(vtkBitArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_bit_array_remove_tuple(vtkBitArray* sself, long long id) { sself->RemoveTuple(id); } +extern "C" void vtk_bit_array_set_component(vtkBitArray* sself, long long i, int j, double c) { sself->SetComponent(i, j, c); } +extern "C" void vtk_bit_array_squeeze(vtkBitArray* sself) { sself->Squeeze(); } +extern "C" int vtk_bit_array_resize(vtkBitArray* sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" int vtk_bit_array_get_value(vtkBitArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_bit_array_set_value(vtkBitArray* sself, long long id, int value) { sself->SetValue(id, value); } +extern "C" void vtk_bit_array_insert_value(vtkBitArray* sself, long long id, int i) { sself->InsertValue(id, i); } +extern "C" long long vtk_bit_array_insert_next_value(vtkBitArray* sself, int i) { return sself->InsertNextValue(i); } +extern "C" void vtk_bit_array_insert_component(vtkBitArray* sself, long long i, int j, double c) { sself->InsertComponent(i, j, c); } +extern "C" void* vtk_bit_array_write_void_pointer(vtkBitArray* sself, long long id, long long number) { return sself->WriteVoidPointer(id, number); } +extern "C" void* vtk_bit_array_get_void_pointer(vtkBitArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_bit_array_set_void_array(vtkBitArray* sself, void* array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" void vtk_bit_array_data_changed(vtkBitArray* sself) { sself->DataChanged(); } +extern "C" void vtk_bit_array_clear_lookup(vtkBitArray* sself) { sself->ClearLookup(); } +extern "C" vtkBitArrayIterator * vtkBitArrayIterator_new () {return vtkBitArrayIterator :: New () ;} +extern "C" void vtkBitArrayIterator_destructor (vtkBitArrayIterator * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bit_array_iterator_get_value(vtkBitArrayIterator* sself, long long id) { return sself->GetValue(id); } +extern "C" long long vtk_bit_array_iterator_get_number_of_tuples(vtkBitArrayIterator* sself) { return sself->GetNumberOfTuples(); } +extern "C" long long vtk_bit_array_iterator_get_number_of_values(vtkBitArrayIterator* sself) { return sself->GetNumberOfValues(); } +extern "C" int vtk_bit_array_iterator_get_number_of_components(vtkBitArrayIterator* sself) { return sself->GetNumberOfComponents(); } +extern "C" int vtk_bit_array_iterator_get_data_type(vtkBitArrayIterator* sself) { return sself->GetDataType(); } +extern "C" int vtk_bit_array_iterator_get_data_type_size(vtkBitArrayIterator* sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_bit_array_iterator_set_value(vtkBitArrayIterator* sself, long long id, int value) { sself->SetValue(id, value); } +extern "C" vtkBoxMuellerRandomSequence * vtkBoxMuellerRandomSequence_new () {return vtkBoxMuellerRandomSequence :: New () ;} +extern "C" void vtkBoxMuellerRandomSequence_destructor (vtkBoxMuellerRandomSequence * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_box_mueller_random_sequence_initialize(vtkBoxMuellerRandomSequence* sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" double vtk_box_mueller_random_sequence_get_value(vtkBoxMuellerRandomSequence* sself) { return sself->GetValue(); } +extern "C" void vtk_box_mueller_random_sequence_next(vtkBoxMuellerRandomSequence* sself) { sself->Next(); } +extern "C" vtkByteSwap * vtkByteSwap_new () {return vtkByteSwap :: New () ;} +extern "C" void vtkByteSwap_destructor (vtkByteSwap * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_byte_swap_swap_2_le(vtkByteSwap* sself, void* p) { sself->Swap2LE(p); } +extern "C" void vtk_byte_swap_swap_4_le(vtkByteSwap* sself, void* p) { sself->Swap4LE(p); } +extern "C" void vtk_byte_swap_swap_8_le(vtkByteSwap* sself, void* p) { sself->Swap8LE(p); } +extern "C" void vtk_byte_swap_swap_2_le_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap2LERange(p, num); } +extern "C" void vtk_byte_swap_swap_4_le_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap4LERange(p, num); } +extern "C" void vtk_byte_swap_swap_8_le_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap8LERange(p, num); } +extern "C" void vtk_byte_swap_swap_2_be(vtkByteSwap* sself, void* p) { sself->Swap2BE(p); } +extern "C" void vtk_byte_swap_swap_4_be(vtkByteSwap* sself, void* p) { sself->Swap4BE(p); } +extern "C" void vtk_byte_swap_swap_8_be(vtkByteSwap* sself, void* p) { sself->Swap8BE(p); } +extern "C" void vtk_byte_swap_swap_2_be_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap2BERange(p, num); } +extern "C" void vtk_byte_swap_swap_4_be_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap4BERange(p, num); } +extern "C" void vtk_byte_swap_swap_8_be_range(vtkByteSwap* sself, void* p, size_t num) { sself->Swap8BERange(p, num); } +extern "C" void vtk_byte_swap_swap_void_range(vtkByteSwap* sself, void* buffer, size_t numWords, size_t wordSize) { sself->SwapVoidRange(buffer, numWords, wordSize); } +extern "C" vtkCallbackCommand * vtkCallbackCommand_new () {return vtkCallbackCommand :: New () ;} +extern "C" void vtkCallbackCommand_destructor (vtkCallbackCommand * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_callback_command_set_client_data(vtkCallbackCommand* sself, void* cd) { sself->SetClientData(cd); } +extern "C" void* vtk_callback_command_get_client_data(vtkCallbackCommand* sself) { return sself->GetClientData(); } +extern "C" void vtk_callback_command_set_abort_flag_on_execute(vtkCallbackCommand* sself, int f) { sself->SetAbortFlagOnExecute(f); } +extern "C" int vtk_callback_command_get_abort_flag_on_execute(vtkCallbackCommand* sself) { return sself->GetAbortFlagOnExecute(); } +extern "C" void vtk_callback_command_abort_flag_on_execute_on(vtkCallbackCommand* sself) { sself->AbortFlagOnExecuteOn(); } +extern "C" void vtk_callback_command_abort_flag_on_execute_off(vtkCallbackCommand* sself) { sself->AbortFlagOnExecuteOff(); } +extern "C" vtkCharArray * vtkCharArray_new () {return vtkCharArray :: New () ;} +extern "C" void vtkCharArray_destructor (vtkCharArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_char_array_get_data_type(vtkCharArray* sself) { return sself->GetDataType(); } +extern "C" void vtk_char_array_set_typed_tuple(vtkCharArray* sself, long long i, const char* tuple) { sself->SetTypedTuple(i, tuple); } +extern "C" void vtk_char_array_insert_typed_tuple(vtkCharArray* sself, long long i, const char* tuple) { sself->InsertTypedTuple(i, tuple); } +extern "C" long long vtk_char_array_insert_next_typed_tuple(vtkCharArray* sself, const char* tuple) { return sself->InsertNextTypedTuple(tuple); } +extern "C" char vtk_char_array_get_value(vtkCharArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_char_array_set_value(vtkCharArray* sself, long long id, char value) { sself->SetValue(id, value); } +extern "C" bool vtk_char_array_set_number_of_values(vtkCharArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_char_array_insert_value(vtkCharArray* sself, long long id, char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_char_array_insert_next_value(vtkCharArray* sself, char f) { return sself->InsertNextValue(f); } +extern "C" char vtk_char_array_get_data_type_value_min(vtkCharArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" char vtk_char_array_get_data_type_value_max(vtkCharArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkCollection * vtkCollection_new () {return vtkCollection :: New () ;} +extern "C" void vtkCollection_destructor (vtkCollection * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_collection_remove_item(vtkCollection* sself, int i) { sself->RemoveItem(i); } +extern "C" void vtk_collection_remove_all_items(vtkCollection* sself) { sself->RemoveAllItems(); } +extern "C" int vtk_collection_get_number_of_items(vtkCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" void vtk_collection_init_traversal(vtkCollection* sself) { sself->InitTraversal(); } +extern "C" vtkCollectionIterator * vtkCollectionIterator_new () {return vtkCollectionIterator :: New () ;} +extern "C" void vtkCollectionIterator_destructor (vtkCollectionIterator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_collection_iterator_init_traversal(vtkCollectionIterator* sself) { sself->InitTraversal(); } +extern "C" void vtk_collection_iterator_go_to_first_item(vtkCollectionIterator* sself) { sself->GoToFirstItem(); } +extern "C" void vtk_collection_iterator_go_to_next_item(vtkCollectionIterator* sself) { sself->GoToNextItem(); } +extern "C" int vtk_collection_iterator_is_done_with_traversal(vtkCollectionIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" vtkCriticalSection * vtkCriticalSection_new () {return vtkCriticalSection :: New () ;} +extern "C" void vtkCriticalSection_destructor (vtkCriticalSection * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_critical_section_lock(vtkCriticalSection* sself) { sself->Lock(); } +extern "C" void vtk_critical_section_unlock(vtkCriticalSection* sself) { sself->Unlock(); } +extern "C" vtkDataArrayCollection * vtkDataArrayCollection_new () {return vtkDataArrayCollection :: New () ;} +extern "C" void vtkDataArrayCollection_destructor (vtkDataArrayCollection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_data_array_collection_get_number_of_items(vtkDataArrayCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkDataArrayCollectionIterator * vtkDataArrayCollectionIterator_new () {return vtkDataArrayCollectionIterator :: New () ;} +extern "C" void vtkDataArrayCollectionIterator_destructor (vtkDataArrayCollectionIterator * sself) {sself -> Delete () ; return ;} +extern "C" vtkDataArraySelection * vtkDataArraySelection_new () {return vtkDataArraySelection :: New () ;} +extern "C" void vtkDataArraySelection_destructor (vtkDataArraySelection * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_data_array_selection_enable_array(vtkDataArraySelection* sself, const char* name) { sself->EnableArray(name); } +extern "C" void vtk_data_array_selection_disable_array(vtkDataArraySelection* sself, const char* name) { sself->DisableArray(name); } +extern "C" int vtk_data_array_selection_array_is_enabled(vtkDataArraySelection* sself, const char* name) { return sself->ArrayIsEnabled(name); } +extern "C" int vtk_data_array_selection_array_exists(vtkDataArraySelection* sself, const char* name) { return sself->ArrayExists(name); } +extern "C" void vtk_data_array_selection_enable_all_arrays(vtkDataArraySelection* sself) { sself->EnableAllArrays(); } +extern "C" void vtk_data_array_selection_disable_all_arrays(vtkDataArraySelection* sself) { sself->DisableAllArrays(); } +extern "C" int vtk_data_array_selection_get_number_of_arrays(vtkDataArraySelection* sself) { return sself->GetNumberOfArrays(); } +extern "C" int vtk_data_array_selection_get_number_of_arrays_enabled(vtkDataArraySelection* sself) { return sself->GetNumberOfArraysEnabled(); } +extern "C" const char* vtk_data_array_selection_get_array_name(vtkDataArraySelection* sself, int index) { return sself->GetArrayName(index); } +extern "C" int vtk_data_array_selection_get_array_index(vtkDataArraySelection* sself, const char* name) { return sself->GetArrayIndex(name); } +extern "C" int vtk_data_array_selection_get_enabled_array_index(vtkDataArraySelection* sself, const char* name) { return sself->GetEnabledArrayIndex(name); } +extern "C" int vtk_data_array_selection_get_array_setting(vtkDataArraySelection* sself, int index) { return sself->GetArraySetting(index); } +extern "C" void vtk_data_array_selection_set_array_setting(vtkDataArraySelection* sself, const char* name, int setting) { sself->SetArraySetting(name, setting); } +extern "C" void vtk_data_array_selection_remove_all_arrays(vtkDataArraySelection* sself) { sself->RemoveAllArrays(); } +extern "C" int vtk_data_array_selection_add_array(vtkDataArraySelection* sself, const char* name, bool state) { return sself->AddArray(name, state); } +extern "C" void vtk_data_array_selection_remove_array_by_index(vtkDataArraySelection* sself, int index) { sself->RemoveArrayByIndex(index); } +extern "C" void vtk_data_array_selection_remove_array_by_name(vtkDataArraySelection* sself, const char* name) { sself->RemoveArrayByName(name); } +extern "C" void vtk_data_array_selection_set_unknown_array_setting(vtkDataArraySelection* sself, int _arg) { sself->SetUnknownArraySetting(_arg); } +extern "C" int vtk_data_array_selection_get_unknown_array_setting(vtkDataArraySelection* sself) { return sself->GetUnknownArraySetting(); } +extern "C" vtkDebugLeaks * vtkDebugLeaks_new () {return vtkDebugLeaks :: New () ;} +extern "C" void vtkDebugLeaks_destructor (vtkDebugLeaks * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_debug_leaks_print_current_leaks(vtkDebugLeaks* sself) { return sself->PrintCurrentLeaks(); } +extern "C" int vtk_debug_leaks_get_exit_error(vtkDebugLeaks* sself) { return sself->GetExitError(); } +extern "C" void vtk_debug_leaks_set_exit_error(vtkDebugLeaks* sself, int p0) { sself->SetExitError(p0); } +extern "C" vtkDoubleArray * vtkDoubleArray_new () {return vtkDoubleArray :: New () ;} +extern "C" void vtkDoubleArray_destructor (vtkDoubleArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_double_array_get_data_type(vtkDoubleArray* sself) { return sself->GetDataType(); } +extern "C" double vtk_double_array_get_value(vtkDoubleArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_double_array_set_value(vtkDoubleArray* sself, long long id, double value) { sself->SetValue(id, value); } +extern "C" bool vtk_double_array_set_number_of_values(vtkDoubleArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_double_array_insert_value(vtkDoubleArray* sself, long long id, double f) { sself->InsertValue(id, f); } +extern "C" long long vtk_double_array_insert_next_value(vtkDoubleArray* sself, double f) { return sself->InsertNextValue(f); } +extern "C" double vtk_double_array_get_data_type_value_min(vtkDoubleArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" double vtk_double_array_get_data_type_value_max(vtkDoubleArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkDynamicLoader * vtkDynamicLoader_new () {return vtkDynamicLoader :: New () ;} +extern "C" void vtkDynamicLoader_destructor (vtkDynamicLoader * sself) {sself -> Delete () ; return ;} +extern "C" const char* vtk_dynamic_loader_lib_prefix(vtkDynamicLoader* sself) { return sself->LibPrefix(); } +extern "C" const char* vtk_dynamic_loader_lib_extension(vtkDynamicLoader* sself) { return sself->LibExtension(); } +extern "C" const char* vtk_dynamic_loader_last_error(vtkDynamicLoader* sself) { return sself->LastError(); } +extern "C" vtkEventDataDevice3D * vtkEventDataDevice3D_new () {return vtkEventDataDevice3D :: New () ;} +extern "C" void vtkEventDataDevice3D_destructor (vtkEventDataDevice3D * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_event_data_device_3_d_set_track_pad_position(vtkEventDataDevice3D* sself, double x, double y) { sself->SetTrackPadPosition(x, y); } +extern "C" vtkEventDataForDevice * vtkEventDataForDevice_new () {return vtkEventDataForDevice :: New () ;} +extern "C" void vtkEventDataForDevice_destructor (vtkEventDataForDevice * sself) {sself -> Delete () ; return ;} +extern "C" vtkEventForwarderCommand * vtkEventForwarderCommand_new () {return vtkEventForwarderCommand :: New () ;} +extern "C" void vtkEventForwarderCommand_destructor (vtkEventForwarderCommand * sself) {sself -> Delete () ; return ;} +extern "C" void* vtk_event_forwarder_command_get_target(vtkEventForwarderCommand* sself) { return sself->GetTarget(); } +extern "C" vtkFileOutputWindow * vtkFileOutputWindow_new () {return vtkFileOutputWindow :: New () ;} +extern "C" void vtkFileOutputWindow_destructor (vtkFileOutputWindow * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_file_output_window_display_text(vtkFileOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } +extern "C" void vtk_file_output_window_set_file_name(vtkFileOutputWindow* sself, const char* _arg) { sself->SetFileName(_arg); } +extern "C" void vtk_file_output_window_set_flush(vtkFileOutputWindow* sself, int _arg) { sself->SetFlush(_arg); } +extern "C" int vtk_file_output_window_get_flush(vtkFileOutputWindow* sself) { return sself->GetFlush(); } +extern "C" void vtk_file_output_window_flush_on(vtkFileOutputWindow* sself) { sself->FlushOn(); } +extern "C" void vtk_file_output_window_flush_off(vtkFileOutputWindow* sself) { sself->FlushOff(); } +extern "C" void vtk_file_output_window_set_append(vtkFileOutputWindow* sself, int _arg) { sself->SetAppend(_arg); } +extern "C" int vtk_file_output_window_get_append(vtkFileOutputWindow* sself) { return sself->GetAppend(); } +extern "C" void vtk_file_output_window_append_on(vtkFileOutputWindow* sself) { sself->AppendOn(); } +extern "C" void vtk_file_output_window_append_off(vtkFileOutputWindow* sself) { sself->AppendOff(); } +extern "C" vtkFloatArray * vtkFloatArray_new () {return vtkFloatArray :: New () ;} +extern "C" void vtkFloatArray_destructor (vtkFloatArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_float_array_get_data_type(vtkFloatArray* sself) { return sself->GetDataType(); } +extern "C" float vtk_float_array_get_value(vtkFloatArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_float_array_set_value(vtkFloatArray* sself, long long id, float value) { sself->SetValue(id, value); } +extern "C" bool vtk_float_array_set_number_of_values(vtkFloatArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_float_array_insert_value(vtkFloatArray* sself, long long id, float f) { sself->InsertValue(id, f); } +extern "C" long long vtk_float_array_insert_next_value(vtkFloatArray* sself, float f) { return sself->InsertNextValue(f); } +extern "C" float vtk_float_array_get_data_type_value_min(vtkFloatArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" float vtk_float_array_get_data_type_value_max(vtkFloatArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkGarbageCollector * vtkGarbageCollector_new () {return vtkGarbageCollector :: New () ;} +extern "C" void vtkGarbageCollector_destructor (vtkGarbageCollector * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_garbage_collector_collect(vtkGarbageCollector* sself) { sself->Collect(); } +extern "C" void vtk_garbage_collector_deferred_collection_push(vtkGarbageCollector* sself) { sself->DeferredCollectionPush(); } +extern "C" void vtk_garbage_collector_deferred_collection_pop(vtkGarbageCollector* sself) { sself->DeferredCollectionPop(); } +extern "C" void vtk_garbage_collector_set_global_debug_flag(vtkGarbageCollector* sself, bool flag) { sself->SetGlobalDebugFlag(flag); } +extern "C" bool vtk_garbage_collector_get_global_debug_flag(vtkGarbageCollector* sself) { return sself->GetGlobalDebugFlag(); } +extern "C" vtkIdList * vtkIdList_new () {return vtkIdList :: New () ;} +extern "C" void vtkIdList_destructor (vtkIdList * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_id_list_initialize(vtkIdList* sself) { sself->Initialize(); } +extern "C" int vtk_id_list_allocate(vtkIdList* sself, const long long sz, const int strategy) { return sself->Allocate(sz, strategy); } +extern "C" long long vtk_id_list_get_number_of_ids(vtkIdList* sself) { return sself->GetNumberOfIds(); } +extern "C" long long vtk_id_list_get_id(vtkIdList* sself, const long long i) { return sself->GetId(i); } +extern "C" long long vtk_id_list_find_id_location(vtkIdList* sself, const long long id) { return sself->FindIdLocation(id); } +extern "C" void vtk_id_list_set_number_of_ids(vtkIdList* sself, const long long number) { sself->SetNumberOfIds(number); } +extern "C" void vtk_id_list_set_id(vtkIdList* sself, const long long i, const long long vtkid) { sself->SetId(i, vtkid); } +extern "C" void vtk_id_list_insert_id(vtkIdList* sself, const long long i, const long long vtkid) { sself->InsertId(i, vtkid); } +extern "C" long long vtk_id_list_insert_next_id(vtkIdList* sself, const long long vtkid) { return sself->InsertNextId(vtkid); } +extern "C" long long vtk_id_list_insert_unique_id(vtkIdList* sself, const long long vtkid) { return sself->InsertUniqueId(vtkid); } +extern "C" void vtk_id_list_sort(vtkIdList* sself) { sself->Sort(); } +extern "C" void vtk_id_list_fill(vtkIdList* sself, long long value) { sself->Fill(value); } +extern "C" void vtk_id_list_reset(vtkIdList* sself) { sself->Reset(); } +extern "C" void vtk_id_list_squeeze(vtkIdList* sself) { sself->Squeeze(); } +extern "C" void vtk_id_list_delete_id(vtkIdList* sself, long long vtkid) { sself->DeleteId(vtkid); } +extern "C" long long vtk_id_list_is_id(vtkIdList* sself, long long vtkid) { return sself->IsId(vtkid); } +extern "C" vtkIdListCollection * vtkIdListCollection_new () {return vtkIdListCollection :: New () ;} +extern "C" void vtkIdListCollection_destructor (vtkIdListCollection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_id_list_collection_get_number_of_items(vtkIdListCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkIdTypeArray * vtkIdTypeArray_new () {return vtkIdTypeArray :: New () ;} +extern "C" void vtkIdTypeArray_destructor (vtkIdTypeArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_id_type_array_get_data_type(vtkIdTypeArray* sself) { return sself->GetDataType(); } +extern "C" long long vtk_id_type_array_get_value(vtkIdTypeArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_id_type_array_set_value(vtkIdTypeArray* sself, long long id, long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_id_type_array_set_number_of_values(vtkIdTypeArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_id_type_array_insert_value(vtkIdTypeArray* sself, long long id, long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_id_type_array_insert_next_value(vtkIdTypeArray* sself, long long f) { return sself->InsertNextValue(f); } +extern "C" long long vtk_id_type_array_get_data_type_value_min(vtkIdTypeArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" long long vtk_id_type_array_get_data_type_value_max(vtkIdTypeArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkInformation * vtkInformation_new () {return vtkInformation :: New () ;} +extern "C" void vtkInformation_destructor (vtkInformation * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_information_modified(vtkInformation* sself) { sself->Modified(); } +extern "C" void vtk_information_clear(vtkInformation* sself) { sself->Clear(); } +extern "C" int vtk_information_get_number_of_keys(vtkInformation* sself) { return sself->GetNumberOfKeys(); } +extern "C" vtkInformationIterator * vtkInformationIterator_new () {return vtkInformationIterator :: New () ;} +extern "C" void vtkInformationIterator_destructor (vtkInformationIterator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_information_iterator_init_traversal(vtkInformationIterator* sself) { sself->InitTraversal(); } +extern "C" void vtk_information_iterator_go_to_first_item(vtkInformationIterator* sself) { sself->GoToFirstItem(); } +extern "C" void vtk_information_iterator_go_to_next_item(vtkInformationIterator* sself) { sself->GoToNextItem(); } +extern "C" int vtk_information_iterator_is_done_with_traversal(vtkInformationIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" vtkInformationKeyLookup * vtkInformationKeyLookup_new () {return vtkInformationKeyLookup :: New () ;} +extern "C" void vtkInformationKeyLookup_destructor (vtkInformationKeyLookup * sself) {sself -> Delete () ; return ;} +extern "C" vtkInformationVector * vtkInformationVector_new () {return vtkInformationVector :: New () ;} +extern "C" void vtkInformationVector_destructor (vtkInformationVector * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_information_vector_get_number_of_information_objects(vtkInformationVector* sself) { return sself->GetNumberOfInformationObjects(); } +extern "C" void vtk_information_vector_set_number_of_information_objects(vtkInformationVector* sself, int n) { sself->SetNumberOfInformationObjects(n); } +extern "C" vtkIntArray * vtkIntArray_new () {return vtkIntArray :: New () ;} +extern "C" void vtkIntArray_destructor (vtkIntArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_int_array_get_data_type(vtkIntArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_int_array_get_value(vtkIntArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_int_array_set_value(vtkIntArray* sself, long long id, int value) { sself->SetValue(id, value); } +extern "C" bool vtk_int_array_set_number_of_values(vtkIntArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_int_array_insert_value(vtkIntArray* sself, long long id, int f) { sself->InsertValue(id, f); } +extern "C" long long vtk_int_array_insert_next_value(vtkIntArray* sself, int f) { return sself->InsertNextValue(f); } +extern "C" int vtk_int_array_get_data_type_value_min(vtkIntArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" int vtk_int_array_get_data_type_value_max(vtkIntArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkLongArray * vtkLongArray_new () {return vtkLongArray :: New () ;} +extern "C" void vtkLongArray_destructor (vtkLongArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_long_array_get_data_type(vtkLongArray* sself) { return sself->GetDataType(); } +extern "C" long vtk_long_array_get_value(vtkLongArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_long_array_set_value(vtkLongArray* sself, long long id, long value) { sself->SetValue(id, value); } +extern "C" bool vtk_long_array_set_number_of_values(vtkLongArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_long_array_insert_value(vtkLongArray* sself, long long id, long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_long_array_insert_next_value(vtkLongArray* sself, long f) { return sself->InsertNextValue(f); } +extern "C" long vtk_long_array_get_data_type_value_min(vtkLongArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" long vtk_long_array_get_data_type_value_max(vtkLongArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkLongLongArray * vtkLongLongArray_new () {return vtkLongLongArray :: New () ;} +extern "C" void vtkLongLongArray_destructor (vtkLongLongArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_long_long_array_get_data_type(vtkLongLongArray* sself) { return sself->GetDataType(); } +extern "C" long long vtk_long_long_array_get_value(vtkLongLongArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_long_long_array_set_value(vtkLongLongArray* sself, long long id, long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_long_long_array_set_number_of_values(vtkLongLongArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_long_long_array_insert_value(vtkLongLongArray* sself, long long id, long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_long_long_array_insert_next_value(vtkLongLongArray* sself, long long f) { return sself->InsertNextValue(f); } +extern "C" long long vtk_long_long_array_get_data_type_value_min(vtkLongLongArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" long long vtk_long_long_array_get_data_type_value_max(vtkLongLongArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkLookupTable * vtkLookupTable_new () {return vtkLookupTable :: New () ;} +extern "C" void vtkLookupTable_destructor (vtkLookupTable * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_lookup_table_is_opaque(vtkLookupTable* sself) { return sself->IsOpaque(); } +extern "C" int vtk_lookup_table_allocate(vtkLookupTable* sself, int sz, int ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_lookup_table_build(vtkLookupTable* sself) { sself->Build(); } +extern "C" void vtk_lookup_table_force_build(vtkLookupTable* sself) { sself->ForceBuild(); } +extern "C" void vtk_lookup_table_build_special_colors(vtkLookupTable* sself) { sself->BuildSpecialColors(); } +extern "C" void vtk_lookup_table_set_ramp(vtkLookupTable* sself, int _arg) { sself->SetRamp(_arg); } +extern "C" void vtk_lookup_table_set_ramp_to_linear(vtkLookupTable* sself) { sself->SetRampToLinear(); } +extern "C" void vtk_lookup_table_set_ramp_to_s_curve(vtkLookupTable* sself) { sself->SetRampToSCurve(); } +extern "C" void vtk_lookup_table_set_ramp_to_sqrt(vtkLookupTable* sself) { sself->SetRampToSQRT(); } +extern "C" int vtk_lookup_table_get_ramp(vtkLookupTable* sself) { return sself->GetRamp(); } +extern "C" void vtk_lookup_table_set_scale(vtkLookupTable* sself, int scale) { sself->SetScale(scale); } +extern "C" void vtk_lookup_table_set_scale_to_linear(vtkLookupTable* sself) { sself->SetScaleToLinear(); } +extern "C" void vtk_lookup_table_set_scale_to_log_10(vtkLookupTable* sself) { sself->SetScaleToLog10(); } +extern "C" int vtk_lookup_table_get_scale(vtkLookupTable* sself) { return sself->GetScale(); } +extern "C" void vtk_lookup_table_set_table_range(vtkLookupTable* sself, double min, double max) { sself->SetTableRange(min, max); } +extern "C" void vtk_lookup_table_set_hue_range(vtkLookupTable* sself, double _arg1, double _arg2) { sself->SetHueRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_saturation_range(vtkLookupTable* sself, double _arg1, double _arg2) { sself->SetSaturationRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_value_range(vtkLookupTable* sself, double _arg1, double _arg2) { sself->SetValueRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_alpha_range(vtkLookupTable* sself, double _arg1, double _arg2) { sself->SetAlphaRange(_arg1, _arg2); } +extern "C" void vtk_lookup_table_set_nan_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetNanColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_below_range_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetBelowRangeColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_use_below_range_color(vtkLookupTable* sself, int _arg) { sself->SetUseBelowRangeColor(_arg); } +extern "C" int vtk_lookup_table_get_use_below_range_color(vtkLookupTable* sself) { return sself->GetUseBelowRangeColor(); } +extern "C" void vtk_lookup_table_use_below_range_color_on(vtkLookupTable* sself) { sself->UseBelowRangeColorOn(); } +extern "C" void vtk_lookup_table_use_below_range_color_off(vtkLookupTable* sself) { sself->UseBelowRangeColorOff(); } +extern "C" void vtk_lookup_table_set_above_range_color(vtkLookupTable* sself, double _arg1, double _arg2, double _arg3, double _arg4) { sself->SetAboveRangeColor(_arg1, _arg2, _arg3, _arg4); } +extern "C" void vtk_lookup_table_set_use_above_range_color(vtkLookupTable* sself, int _arg) { sself->SetUseAboveRangeColor(_arg); } +extern "C" int vtk_lookup_table_get_use_above_range_color(vtkLookupTable* sself) { return sself->GetUseAboveRangeColor(); } +extern "C" void vtk_lookup_table_use_above_range_color_on(vtkLookupTable* sself) { sself->UseAboveRangeColorOn(); } +extern "C" void vtk_lookup_table_use_above_range_color_off(vtkLookupTable* sself) { sself->UseAboveRangeColorOff(); } +extern "C" double vtk_lookup_table_get_opacity(vtkLookupTable* sself, double v) { return sself->GetOpacity(v); } +extern "C" long long vtk_lookup_table_get_index(vtkLookupTable* sself, double v) { return sself->GetIndex(v); } +extern "C" void vtk_lookup_table_set_number_of_table_values(vtkLookupTable* sself, long long number) { sself->SetNumberOfTableValues(number); } +extern "C" long long vtk_lookup_table_get_number_of_table_values(vtkLookupTable* sself) { return sself->GetNumberOfTableValues(); } +extern "C" void vtk_lookup_table_set_table_value(vtkLookupTable* sself, long long indx, double r, double g, double b, double a) { sself->SetTableValue(indx, r, g, b, a); } +extern "C" void vtk_lookup_table_set_number_of_colors(vtkLookupTable* sself, long long _arg) { sself->SetNumberOfColors(_arg); } +extern "C" long long vtk_lookup_table_get_number_of_colors_min_value(vtkLookupTable* sself) { return sself->GetNumberOfColorsMinValue(); } +extern "C" long long vtk_lookup_table_get_number_of_colors_max_value(vtkLookupTable* sself) { return sself->GetNumberOfColorsMaxValue(); } +extern "C" long long vtk_lookup_table_get_number_of_colors(vtkLookupTable* sself) { return sself->GetNumberOfColors(); } +extern "C" int vtk_lookup_table_using_log_scale(vtkLookupTable* sself) { return sself->UsingLogScale(); } +extern "C" vtkMath * vtkMath_new () {return vtkMath :: New () ;} +extern "C" void vtkMath_destructor (vtkMath * sself) {sself -> Delete () ; return ;} +extern "C" double vtk_math_pi(vtkMath* sself) { return sself->Pi(); } +extern "C" float vtk_math_radians_from_degrees(vtkMath* sself, float degrees) { return sself->RadiansFromDegrees(degrees); } +extern "C" float vtk_math_degrees_from_radians(vtkMath* sself, float radians) { return sself->DegreesFromRadians(radians); } +extern "C" int vtk_math_round(vtkMath* sself, float f) { return sself->Round(f); } +extern "C" int vtk_math_floor(vtkMath* sself, double x) { return sself->Floor(x); } +extern "C" int vtk_math_ceil(vtkMath* sself, double x) { return sself->Ceil(x); } +extern "C" int vtk_math_ceil_log_2(vtkMath* sself, unsigned long long x) { return sself->CeilLog2(x); } +extern "C" bool vtk_math_is_power_of_two(vtkMath* sself, unsigned long long x) { return sself->IsPowerOfTwo(x); } +extern "C" int vtk_math_nearest_power_of_two(vtkMath* sself, int x) { return sself->NearestPowerOfTwo(x); } +extern "C" long long vtk_math_factorial(vtkMath* sself, int N) { return sself->Factorial(N); } +extern "C" long long vtk_math_binomial(vtkMath* sself, int m, int n) { return sself->Binomial(m, n); } +extern "C" void vtk_math_random_seed(vtkMath* sself, int s) { sself->RandomSeed(s); } +extern "C" int vtk_math_get_seed(vtkMath* sself) { return sself->GetSeed(); } +extern "C" double vtk_math_random(vtkMath* sself) { return sself->Random(); } +extern "C" double vtk_math_gaussian(vtkMath* sself) { return sself->Gaussian(); } +extern "C" double vtk_math_gaussian_amplitude(vtkMath* sself, const double variance, const double distanceFromMean) { return sself->GaussianAmplitude(variance, distanceFromMean); } +extern "C" double vtk_math_gaussian_weight(vtkMath* sself, const double variance, const double distanceFromMean) { return sself->GaussianWeight(variance, distanceFromMean); } +extern "C" double vtk_math_determinant_2_x_2(vtkMath* sself, double a, double b, double c, double d) { return sself->Determinant2x2(a, b, c, d); } +extern "C" double vtk_math_determinant_3_x_3(vtkMath* sself, double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3) { return sself->Determinant3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3); } +extern "C" int vtk_math_solve_linear_system_gepp_2_x_2(vtkMath* sself, double a00, double a01, double a10, double a11, double b0, double b1, double& x0, double& x1) { return sself->SolveLinearSystemGEPP2x2(a00, a01, a10, a11, b0, b1, x0, x1); } +extern "C" int vtk_math_get_scalar_type_fitting_range(vtkMath* sself, double range_min, double range_max, double scale, double shift) { return sself->GetScalarTypeFittingRange(range_min, range_max, scale, shift); } +extern "C" double vtk_math_inf(vtkMath* sself) { return sself->Inf(); } +extern "C" double vtk_math_neg_inf(vtkMath* sself) { return sself->NegInf(); } +extern "C" double vtk_math_nan(vtkMath* sself) { return sself->Nan(); } +extern "C" int vtk_math_is_inf(vtkMath* sself, double x) { return sself->IsInf(x); } +extern "C" int vtk_math_is_nan(vtkMath* sself, double x) { return sself->IsNan(x); } +extern "C" bool vtk_math_is_finite(vtkMath* sself, double x) { return sself->IsFinite(x); } +extern "C" vtkMersenneTwister * vtkMersenneTwister_new () {return vtkMersenneTwister :: New () ;} +extern "C" void vtkMersenneTwister_destructor (vtkMersenneTwister * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_mersenne_twister_initialize(vtkMersenneTwister* sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" unsigned int vtk_mersenne_twister_initialize_new_sequence(vtkMersenneTwister* sself, unsigned int seed, int p) { return sself->InitializeNewSequence(seed, p); } +extern "C" void vtk_mersenne_twister_initialize_sequence(vtkMersenneTwister* sself, unsigned int id, unsigned int seed, int p) { sself->InitializeSequence(id, seed, p); } +extern "C" double vtk_mersenne_twister_get_value(vtkMersenneTwister* sself, unsigned int id) { return sself->GetValue(id); } +extern "C" void vtk_mersenne_twister_next(vtkMersenneTwister* sself, unsigned int id) { sself->Next(id); } +extern "C" vtkMinimalStandardRandomSequence * vtkMinimalStandardRandomSequence_new () {return vtkMinimalStandardRandomSequence :: New () ;} +extern "C" void vtkMinimalStandardRandomSequence_destructor (vtkMinimalStandardRandomSequence * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_minimal_standard_random_sequence_initialize(vtkMinimalStandardRandomSequence* sself, unsigned int seed) { sself->Initialize(seed); } +extern "C" void vtk_minimal_standard_random_sequence_set_seed(vtkMinimalStandardRandomSequence* sself, int value) { sself->SetSeed(value); } +extern "C" void vtk_minimal_standard_random_sequence_set_seed_only(vtkMinimalStandardRandomSequence* sself, int value) { sself->SetSeedOnly(value); } +extern "C" int vtk_minimal_standard_random_sequence_get_seed(vtkMinimalStandardRandomSequence* sself) { return sself->GetSeed(); } +extern "C" double vtk_minimal_standard_random_sequence_get_value(vtkMinimalStandardRandomSequence* sself) { return sself->GetValue(); } +extern "C" void vtk_minimal_standard_random_sequence_next(vtkMinimalStandardRandomSequence* sself) { sself->Next(); } +extern "C" double vtk_minimal_standard_random_sequence_get_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax) { return sself->GetRangeValue(rangeMin, rangeMax); } +extern "C" double vtk_minimal_standard_random_sequence_get_next_range_value(vtkMinimalStandardRandomSequence* sself, double rangeMin, double rangeMax) { return sself->GetNextRangeValue(rangeMin, rangeMax); } +extern "C" vtkMultiThreader * vtkMultiThreader_new () {return vtkMultiThreader :: New () ;} +extern "C" void vtkMultiThreader_destructor (vtkMultiThreader * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_multi_threader_set_number_of_threads(vtkMultiThreader* sself, int _arg) { sself->SetNumberOfThreads(_arg); } +extern "C" int vtk_multi_threader_get_number_of_threads_min_value(vtkMultiThreader* sself) { return sself->GetNumberOfThreadsMinValue(); } +extern "C" int vtk_multi_threader_get_number_of_threads_max_value(vtkMultiThreader* sself) { return sself->GetNumberOfThreadsMaxValue(); } +extern "C" int vtk_multi_threader_get_number_of_threads(vtkMultiThreader* sself) { return sself->GetNumberOfThreads(); } +extern "C" int vtk_multi_threader_get_global_static_maximum_number_of_threads(vtkMultiThreader* sself) { return sself->GetGlobalStaticMaximumNumberOfThreads(); } +extern "C" void vtk_multi_threader_set_global_maximum_number_of_threads(vtkMultiThreader* sself, int val) { sself->SetGlobalMaximumNumberOfThreads(val); } +extern "C" int vtk_multi_threader_get_global_maximum_number_of_threads(vtkMultiThreader* sself) { return sself->GetGlobalMaximumNumberOfThreads(); } +extern "C" void vtk_multi_threader_set_global_default_number_of_threads(vtkMultiThreader* sself, int val) { sself->SetGlobalDefaultNumberOfThreads(val); } +extern "C" int vtk_multi_threader_get_global_default_number_of_threads(vtkMultiThreader* sself) { return sself->GetGlobalDefaultNumberOfThreads(); } +extern "C" void vtk_multi_threader_single_method_execute(vtkMultiThreader* sself) { sself->SingleMethodExecute(); } +extern "C" void vtk_multi_threader_multiple_method_execute(vtkMultiThreader* sself) { sself->MultipleMethodExecute(); } +extern "C" void vtk_multi_threader_terminate_thread(vtkMultiThreader* sself, int threadId) { sself->TerminateThread(threadId); } +extern "C" int vtk_multi_threader_is_thread_active(vtkMultiThreader* sself, int threadId) { return sself->IsThreadActive(threadId); } +extern "C" vtkObject * vtkObject_new () {return vtkObject :: New () ;} +extern "C" void vtkObject_destructor (vtkObject * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_object_is_type_of(vtkObject* sself, const char* type) { return sself->IsTypeOf(type); } +extern "C" int vtk_object_is_a(vtkObject* sself, const char* type) { return sself->IsA(type); } +extern "C" long long vtk_object_get_number_of_generations_from_base_type(vtkObject* sself, const char* type) { return sself->GetNumberOfGenerationsFromBaseType(type); } +extern "C" long long vtk_object_get_number_of_generations_from_base(vtkObject* sself, const char* type) { return sself->GetNumberOfGenerationsFromBase(type); } +extern "C" void vtk_object_debug_on(vtkObject* sself) { sself->DebugOn(); } +extern "C" void vtk_object_debug_off(vtkObject* sself) { sself->DebugOff(); } +extern "C" bool vtk_object_get_debug(vtkObject* sself) { return sself->GetDebug(); } +extern "C" void vtk_object_set_debug(vtkObject* sself, bool debugFlag) { sself->SetDebug(debugFlag); } +extern "C" void vtk_object_break_on_error(vtkObject* sself) { sself->BreakOnError(); } +extern "C" void vtk_object_modified(vtkObject* sself) { sself->Modified(); } +extern "C" unsigned long vtk_object_get_m_time(vtkObject* sself) { return sself->GetMTime(); } +extern "C" void vtk_object_set_global_warning_display(vtkObject* sself, int val) { sself->SetGlobalWarningDisplay(val); } +extern "C" void vtk_object_global_warning_display_on(vtkObject* sself) { sself->GlobalWarningDisplayOn(); } +extern "C" void vtk_object_global_warning_display_off(vtkObject* sself) { sself->GlobalWarningDisplayOff(); } +extern "C" int vtk_object_get_global_warning_display(vtkObject* sself) { return sself->GetGlobalWarningDisplay(); } +extern "C" void vtk_object_remove_all_observers(vtkObject* sself) { sself->RemoveAllObservers(); } +extern "C" int vtk_object_invoke_event(vtkObject* sself, unsigned long event, void* callData) { return sself->InvokeEvent(event, callData); } +extern "C" vtkObjectFactoryCollection * vtkObjectFactoryCollection_new () {return vtkObjectFactoryCollection :: New () ;} +extern "C" void vtkObjectFactoryCollection_destructor (vtkObjectFactoryCollection * sself) {sself -> Delete () ; return ;} +extern "C" vtkOldStyleCallbackCommand * vtkOldStyleCallbackCommand_new () {return vtkOldStyleCallbackCommand :: New () ;} +extern "C" void vtkOldStyleCallbackCommand_destructor (vtkOldStyleCallbackCommand * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_old_style_callback_command_set_client_data(vtkOldStyleCallbackCommand* sself, void* cd) { sself->SetClientData(cd); } +extern "C" vtkOutputWindow * vtkOutputWindow_new () {return vtkOutputWindow :: New () ;} +extern "C" void vtkOutputWindow_destructor (vtkOutputWindow * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_output_window_display_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } +extern "C" void vtk_output_window_display_error_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayErrorText(p0); } +extern "C" void vtk_output_window_display_warning_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayWarningText(p0); } +extern "C" void vtk_output_window_display_generic_warning_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayGenericWarningText(p0); } +extern "C" void vtk_output_window_display_debug_text(vtkOutputWindow* sself, const char* p0) { sself->DisplayDebugText(p0); } +extern "C" void vtk_output_window_prompt_user_on(vtkOutputWindow* sself) { sself->PromptUserOn(); } +extern "C" void vtk_output_window_prompt_user_off(vtkOutputWindow* sself) { sself->PromptUserOff(); } +extern "C" void vtk_output_window_set_prompt_user(vtkOutputWindow* sself, bool _arg) { sself->SetPromptUser(_arg); } +extern "C" void vtk_output_window_set_use_std_error_for_all_messages(vtkOutputWindow* sself, bool p0) { sself->SetUseStdErrorForAllMessages(p0); } +extern "C" bool vtk_output_window_get_use_std_error_for_all_messages(vtkOutputWindow* sself) { return sself->GetUseStdErrorForAllMessages(); } +extern "C" void vtk_output_window_use_std_error_for_all_messages_on(vtkOutputWindow* sself) { sself->UseStdErrorForAllMessagesOn(); } +extern "C" void vtk_output_window_use_std_error_for_all_messages_off(vtkOutputWindow* sself) { sself->UseStdErrorForAllMessagesOff(); } +extern "C" void vtk_output_window_set_display_mode(vtkOutputWindow* sself, int _arg) { sself->SetDisplayMode(_arg); } +extern "C" int vtk_output_window_get_display_mode_min_value(vtkOutputWindow* sself) { return sself->GetDisplayModeMinValue(); } +extern "C" int vtk_output_window_get_display_mode_max_value(vtkOutputWindow* sself) { return sself->GetDisplayModeMaxValue(); } +extern "C" int vtk_output_window_get_display_mode(vtkOutputWindow* sself) { return sself->GetDisplayMode(); } +extern "C" void vtk_output_window_set_display_mode_to_default(vtkOutputWindow* sself) { sself->SetDisplayModeToDefault(); } +extern "C" void vtk_output_window_set_display_mode_to_never(vtkOutputWindow* sself) { sself->SetDisplayModeToNever(); } +extern "C" void vtk_output_window_set_display_mode_to_always(vtkOutputWindow* sself) { sself->SetDisplayModeToAlways(); } +extern "C" void vtk_output_window_set_display_mode_to_always_std_err(vtkOutputWindow* sself) { sself->SetDisplayModeToAlwaysStdErr(); } +extern "C" vtkOverrideInformationCollection * vtkOverrideInformationCollection_new () {return vtkOverrideInformationCollection :: New () ;} +extern "C" void vtkOverrideInformationCollection_destructor (vtkOverrideInformationCollection * sself) {sself -> Delete () ; return ;} +extern "C" vtkPoints * vtkPoints_new () {return vtkPoints :: New () ;} +extern "C" void vtkPoints_destructor (vtkPoints * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_points_allocate(vtkPoints* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_points_initialize(vtkPoints* sself) { sself->Initialize(); } +extern "C" int vtk_points_get_data_type(vtkPoints* sself) { return sself->GetDataType(); } +extern "C" void vtk_points_set_data_type(vtkPoints* sself, int dataType) { sself->SetDataType(dataType); } +extern "C" void vtk_points_set_data_type_to_bit(vtkPoints* sself) { sself->SetDataTypeToBit(); } +extern "C" void vtk_points_set_data_type_to_char(vtkPoints* sself) { sself->SetDataTypeToChar(); } +extern "C" void vtk_points_set_data_type_to_unsigned_char(vtkPoints* sself) { sself->SetDataTypeToUnsignedChar(); } +extern "C" void vtk_points_set_data_type_to_short(vtkPoints* sself) { sself->SetDataTypeToShort(); } +extern "C" void vtk_points_set_data_type_to_unsigned_short(vtkPoints* sself) { sself->SetDataTypeToUnsignedShort(); } +extern "C" void vtk_points_set_data_type_to_int(vtkPoints* sself) { sself->SetDataTypeToInt(); } +extern "C" void vtk_points_set_data_type_to_unsigned_int(vtkPoints* sself) { sself->SetDataTypeToUnsignedInt(); } +extern "C" void vtk_points_set_data_type_to_long(vtkPoints* sself) { sself->SetDataTypeToLong(); } +extern "C" void vtk_points_set_data_type_to_unsigned_long(vtkPoints* sself) { sself->SetDataTypeToUnsignedLong(); } +extern "C" void vtk_points_set_data_type_to_float(vtkPoints* sself) { sself->SetDataTypeToFloat(); } +extern "C" void vtk_points_set_data_type_to_double(vtkPoints* sself) { sself->SetDataTypeToDouble(); } +extern "C" void* vtk_points_get_void_pointer(vtkPoints* sself, const int id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_points_squeeze(vtkPoints* sself) { sself->Squeeze(); } +extern "C" void vtk_points_reset(vtkPoints* sself) { sself->Reset(); } +extern "C" unsigned long vtk_points_get_actual_memory_size(vtkPoints* sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_points_get_number_of_points(vtkPoints* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_points_set_point(vtkPoints* sself, long long id, double x, double y, double z) { sself->SetPoint(id, x, y, z); } +extern "C" void vtk_points_insert_point(vtkPoints* sself, long long id, double x, double y, double z) { sself->InsertPoint(id, x, y, z); } +extern "C" long long vtk_points_insert_next_point(vtkPoints* sself, double x, double y, double z) { return sself->InsertNextPoint(x, y, z); } +extern "C" void vtk_points_set_number_of_points(vtkPoints* sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } +extern "C" int vtk_points_resize(vtkPoints* sself, long long numPoints) { return sself->Resize(numPoints); } +extern "C" void vtk_points_compute_bounds(vtkPoints* sself) { sself->ComputeBounds(); } +extern "C" unsigned long vtk_points_get_m_time(vtkPoints* sself) { return sself->GetMTime(); } +extern "C" void vtk_points_modified(vtkPoints* sself) { sself->Modified(); } +extern "C" vtkPoints2D * vtkPoints2D_new () {return vtkPoints2D :: New () ;} +extern "C" void vtkPoints2D_destructor (vtkPoints2D * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_points_2_d_allocate(vtkPoints2D* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_points_2_d_initialize(vtkPoints2D* sself) { sself->Initialize(); } +extern "C" int vtk_points_2_d_get_data_type(vtkPoints2D* sself) { return sself->GetDataType(); } +extern "C" void vtk_points_2_d_set_data_type(vtkPoints2D* sself, int dataType) { sself->SetDataType(dataType); } +extern "C" void vtk_points_2_d_set_data_type_to_bit(vtkPoints2D* sself) { sself->SetDataTypeToBit(); } +extern "C" void vtk_points_2_d_set_data_type_to_char(vtkPoints2D* sself) { sself->SetDataTypeToChar(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_char(vtkPoints2D* sself) { sself->SetDataTypeToUnsignedChar(); } +extern "C" void vtk_points_2_d_set_data_type_to_short(vtkPoints2D* sself) { sself->SetDataTypeToShort(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_short(vtkPoints2D* sself) { sself->SetDataTypeToUnsignedShort(); } +extern "C" void vtk_points_2_d_set_data_type_to_int(vtkPoints2D* sself) { sself->SetDataTypeToInt(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_int(vtkPoints2D* sself) { sself->SetDataTypeToUnsignedInt(); } +extern "C" void vtk_points_2_d_set_data_type_to_long(vtkPoints2D* sself) { sself->SetDataTypeToLong(); } +extern "C" void vtk_points_2_d_set_data_type_to_unsigned_long(vtkPoints2D* sself) { sself->SetDataTypeToUnsignedLong(); } +extern "C" void vtk_points_2_d_set_data_type_to_float(vtkPoints2D* sself) { sself->SetDataTypeToFloat(); } +extern "C" void vtk_points_2_d_set_data_type_to_double(vtkPoints2D* sself) { sself->SetDataTypeToDouble(); } +extern "C" void* vtk_points_2_d_get_void_pointer(vtkPoints2D* sself, const int id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_points_2_d_squeeze(vtkPoints2D* sself) { sself->Squeeze(); } +extern "C" void vtk_points_2_d_reset(vtkPoints2D* sself) { sself->Reset(); } +extern "C" unsigned long vtk_points_2_d_get_actual_memory_size(vtkPoints2D* sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_points_2_d_get_number_of_points(vtkPoints2D* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_points_2_d_set_point(vtkPoints2D* sself, long long id, double x, double y) { sself->SetPoint(id, x, y); } +extern "C" void vtk_points_2_d_insert_point(vtkPoints2D* sself, long long id, double x, double y) { sself->InsertPoint(id, x, y); } +extern "C" long long vtk_points_2_d_insert_next_point(vtkPoints2D* sself, double x, double y) { return sself->InsertNextPoint(x, y); } +extern "C" void vtk_points_2_d_remove_point(vtkPoints2D* sself, long long id) { sself->RemovePoint(id); } +extern "C" void vtk_points_2_d_set_number_of_points(vtkPoints2D* sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } +extern "C" int vtk_points_2_d_resize(vtkPoints2D* sself, long long numPoints) { return sself->Resize(numPoints); } +extern "C" void vtk_points_2_d_compute_bounds(vtkPoints2D* sself) { sself->ComputeBounds(); } +extern "C" vtkPriorityQueue * vtkPriorityQueue_new () {return vtkPriorityQueue :: New () ;} +extern "C" void vtkPriorityQueue_destructor (vtkPriorityQueue * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_priority_queue_allocate(vtkPriorityQueue* sself, long long sz, long long ext) { sself->Allocate(sz, ext); } +extern "C" void vtk_priority_queue_insert(vtkPriorityQueue* sself, double priority, long long id) { sself->Insert(priority, id); } +extern "C" long long vtk_priority_queue_pop(vtkPriorityQueue* sself, long long location, double& priority) { return sself->Pop(location, priority); } +extern "C" long long vtk_priority_queue_peek(vtkPriorityQueue* sself, long long location, double& priority) { return sself->Peek(location, priority); } +extern "C" double vtk_priority_queue_delete_id(vtkPriorityQueue* sself, long long id) { return sself->DeleteId(id); } +extern "C" double vtk_priority_queue_get_priority(vtkPriorityQueue* sself, long long id) { return sself->GetPriority(id); } +extern "C" long long vtk_priority_queue_get_number_of_items(vtkPriorityQueue* sself) { return sself->GetNumberOfItems(); } +extern "C" void vtk_priority_queue_reset(vtkPriorityQueue* sself) { sself->Reset(); } +extern "C" vtkRandomPool * vtkRandomPool_new () {return vtkRandomPool :: New () ;} +extern "C" void vtkRandomPool_destructor (vtkRandomPool * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_random_pool_set_size(vtkRandomPool* sself, long long _arg) { sself->SetSize(_arg); } +extern "C" long long vtk_random_pool_get_size_min_value(vtkRandomPool* sself) { return sself->GetSizeMinValue(); } +extern "C" long long vtk_random_pool_get_size_max_value(vtkRandomPool* sself) { return sself->GetSizeMaxValue(); } +extern "C" long long vtk_random_pool_get_size(vtkRandomPool* sself) { return sself->GetSize(); } +extern "C" void vtk_random_pool_set_number_of_components(vtkRandomPool* sself, long long _arg) { sself->SetNumberOfComponents(_arg); } +extern "C" long long vtk_random_pool_get_number_of_components_min_value(vtkRandomPool* sself) { return sself->GetNumberOfComponentsMinValue(); } +extern "C" long long vtk_random_pool_get_number_of_components_max_value(vtkRandomPool* sself) { return sself->GetNumberOfComponentsMaxValue(); } +extern "C" long long vtk_random_pool_get_number_of_components(vtkRandomPool* sself) { return sself->GetNumberOfComponents(); } +extern "C" long long vtk_random_pool_get_total_size(vtkRandomPool* sself) { return sself->GetTotalSize(); } +extern "C" double vtk_random_pool_get_value(vtkRandomPool* sself, long long i) { return sself->GetValue(i); } +extern "C" void vtk_random_pool_set_chunk_size(vtkRandomPool* sself, long long _arg) { sself->SetChunkSize(_arg); } +extern "C" long long vtk_random_pool_get_chunk_size_min_value(vtkRandomPool* sself) { return sself->GetChunkSizeMinValue(); } +extern "C" long long vtk_random_pool_get_chunk_size_max_value(vtkRandomPool* sself) { return sself->GetChunkSizeMaxValue(); } +extern "C" long long vtk_random_pool_get_chunk_size(vtkRandomPool* sself) { return sself->GetChunkSize(); } +extern "C" vtkReferenceCount * vtkReferenceCount_new () {return vtkReferenceCount :: New () ;} +extern "C" void vtkReferenceCount_destructor (vtkReferenceCount * sself) {sself -> Delete () ; return ;} +extern "C" vtkScalarsToColors * vtkScalarsToColors_new () {return vtkScalarsToColors :: New () ;} +extern "C" void vtkScalarsToColors_destructor (vtkScalarsToColors * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_scalars_to_colors_is_opaque(vtkScalarsToColors* sself) { return sself->IsOpaque(); } +extern "C" void vtk_scalars_to_colors_build(vtkScalarsToColors* sself) { sself->Build(); } +extern "C" void vtk_scalars_to_colors_set_range(vtkScalarsToColors* sself, double min, double max) { sself->SetRange(min, max); } +extern "C" double vtk_scalars_to_colors_get_opacity(vtkScalarsToColors* sself, double v) { return sself->GetOpacity(v); } +extern "C" double vtk_scalars_to_colors_get_luminance(vtkScalarsToColors* sself, double x) { return sself->GetLuminance(x); } +extern "C" void vtk_scalars_to_colors_set_alpha(vtkScalarsToColors* sself, double alpha) { sself->SetAlpha(alpha); } +extern "C" double vtk_scalars_to_colors_get_alpha(vtkScalarsToColors* sself) { return sself->GetAlpha(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode(vtkScalarsToColors* sself, int _arg) { sself->SetVectorMode(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_mode(vtkScalarsToColors* sself) { return sself->GetVectorMode(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_magnitude(vtkScalarsToColors* sself) { sself->SetVectorModeToMagnitude(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_component(vtkScalarsToColors* sself) { sself->SetVectorModeToComponent(); } +extern "C" void vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(vtkScalarsToColors* sself) { sself->SetVectorModeToRGBColors(); } +extern "C" void vtk_scalars_to_colors_set_vector_component(vtkScalarsToColors* sself, int _arg) { sself->SetVectorComponent(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_component(vtkScalarsToColors* sself) { return sself->GetVectorComponent(); } +extern "C" void vtk_scalars_to_colors_set_vector_size(vtkScalarsToColors* sself, int _arg) { sself->SetVectorSize(_arg); } +extern "C" int vtk_scalars_to_colors_get_vector_size(vtkScalarsToColors* sself) { return sself->GetVectorSize(); } +extern "C" int vtk_scalars_to_colors_using_log_scale(vtkScalarsToColors* sself) { return sself->UsingLogScale(); } +extern "C" long long vtk_scalars_to_colors_get_number_of_available_colors(vtkScalarsToColors* sself) { return sself->GetNumberOfAvailableColors(); } +extern "C" long long vtk_scalars_to_colors_get_number_of_annotated_values(vtkScalarsToColors* sself) { return sself->GetNumberOfAnnotatedValues(); } +extern "C" void vtk_scalars_to_colors_reset_annotations(vtkScalarsToColors* sself) { sself->ResetAnnotations(); } +extern "C" void vtk_scalars_to_colors_set_indexed_lookup(vtkScalarsToColors* sself, int _arg) { sself->SetIndexedLookup(_arg); } +extern "C" int vtk_scalars_to_colors_get_indexed_lookup(vtkScalarsToColors* sself) { return sself->GetIndexedLookup(); } +extern "C" void vtk_scalars_to_colors_indexed_lookup_on(vtkScalarsToColors* sself) { sself->IndexedLookupOn(); } +extern "C" void vtk_scalars_to_colors_indexed_lookup_off(vtkScalarsToColors* sself) { sself->IndexedLookupOff(); } +extern "C" vtkShortArray * vtkShortArray_new () {return vtkShortArray :: New () ;} +extern "C" void vtkShortArray_destructor (vtkShortArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_short_array_get_data_type(vtkShortArray* sself) { return sself->GetDataType(); } +extern "C" short vtk_short_array_get_value(vtkShortArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_short_array_set_value(vtkShortArray* sself, long long id, short value) { sself->SetValue(id, value); } +extern "C" bool vtk_short_array_set_number_of_values(vtkShortArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_short_array_insert_value(vtkShortArray* sself, long long id, short f) { sself->InsertValue(id, f); } +extern "C" long long vtk_short_array_insert_next_value(vtkShortArray* sself, short f) { return sself->InsertNextValue(f); } +extern "C" short vtk_short_array_get_data_type_value_min(vtkShortArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" short vtk_short_array_get_data_type_value_max(vtkShortArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkSignedCharArray * vtkSignedCharArray_new () {return vtkSignedCharArray :: New () ;} +extern "C" void vtkSignedCharArray_destructor (vtkSignedCharArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_signed_char_array_get_data_type(vtkSignedCharArray* sself) { return sself->GetDataType(); } +extern "C" signed char vtk_signed_char_array_get_value(vtkSignedCharArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_signed_char_array_set_value(vtkSignedCharArray* sself, long long id, signed char value) { sself->SetValue(id, value); } +extern "C" bool vtk_signed_char_array_set_number_of_values(vtkSignedCharArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_signed_char_array_insert_value(vtkSignedCharArray* sself, long long id, signed char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_signed_char_array_insert_next_value(vtkSignedCharArray* sself, signed char f) { return sself->InsertNextValue(f); } +extern "C" signed char vtk_signed_char_array_get_data_type_value_min(vtkSignedCharArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" signed char vtk_signed_char_array_get_data_type_value_max(vtkSignedCharArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkSortDataArray * vtkSortDataArray_new () {return vtkSortDataArray :: New () ;} +extern "C" void vtkSortDataArray_destructor (vtkSortDataArray * sself) {sself -> Delete () ; return ;} +extern "C" vtkStringArray * vtkStringArray_new () {return vtkStringArray :: New () ;} +extern "C" void vtkStringArray_destructor (vtkStringArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_string_array_get_data_type(vtkStringArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_string_array_is_numeric(vtkStringArray* sself) { return sself->IsNumeric(); } +extern "C" void vtk_string_array_initialize(vtkStringArray* sself) { sself->Initialize(); } +extern "C" int vtk_string_array_get_data_type_size(vtkStringArray* sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_string_array_squeeze(vtkStringArray* sself) { sself->Squeeze(); } +extern "C" int vtk_string_array_resize(vtkStringArray* sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" int vtk_string_array_allocate(vtkStringArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_string_array_set_number_of_tuples(vtkStringArray* sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" long long vtk_string_array_get_number_of_values(vtkStringArray* sself) { return sself->GetNumberOfValues(); } +extern "C" int vtk_string_array_get_number_of_element_components(vtkStringArray* sself) { return sself->GetNumberOfElementComponents(); } +extern "C" int vtk_string_array_get_element_component_size(vtkStringArray* sself) { return sself->GetElementComponentSize(); } +extern "C" void* vtk_string_array_get_void_pointer(vtkStringArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_string_array_set_void_array(vtkStringArray* sself, void* array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" unsigned long vtk_string_array_get_actual_memory_size(vtkStringArray* sself) { return sself->GetActualMemorySize(); } +extern "C" long long vtk_string_array_get_data_size(vtkStringArray* sself) { return sself->GetDataSize(); } +extern "C" void vtk_string_array_data_changed(vtkStringArray* sself) { sself->DataChanged(); } +extern "C" void vtk_string_array_data_element_changed(vtkStringArray* sself, long long id) { sself->DataElementChanged(id); } +extern "C" void vtk_string_array_clear_lookup(vtkStringArray* sself) { sself->ClearLookup(); } +extern "C" vtkStringOutputWindow * vtkStringOutputWindow_new () {return vtkStringOutputWindow :: New () ;} +extern "C" void vtkStringOutputWindow_destructor (vtkStringOutputWindow * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_string_output_window_display_text(vtkStringOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } +extern "C" vtkTimePointUtility * vtkTimePointUtility_new () {return vtkTimePointUtility :: New () ;} +extern "C" void vtkTimePointUtility_destructor (vtkTimePointUtility * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long long vtk_time_point_utility_date_to_time_point(vtkTimePointUtility* sself, int year, int month, int day) { return sself->DateToTimePoint(year, month, day); } +extern "C" unsigned long long vtk_time_point_utility_time_to_time_point(vtkTimePointUtility* sself, int hour, int minute, int second, int millis) { return sself->TimeToTimePoint(hour, minute, second, millis); } +extern "C" unsigned long long vtk_time_point_utility_date_time_to_time_point(vtkTimePointUtility* sself, int year, int month, int day, int hour, int minute, int sec, int millis) { return sself->DateTimeToTimePoint(year, month, day, hour, minute, sec, millis); } +extern "C" void vtk_time_point_utility_get_date(vtkTimePointUtility* sself, unsigned long long time, int& year, int& month, int& day) { sself->GetDate(time, year, month, day); } +extern "C" void vtk_time_point_utility_get_time(vtkTimePointUtility* sself, unsigned long long time, int& hour, int& minute, int& second, int& millis) { sself->GetTime(time, hour, minute, second, millis); } +extern "C" void vtk_time_point_utility_get_date_time(vtkTimePointUtility* sself, unsigned long long time, int& year, int& month, int& day, int& hour, int& minute, int& second, int& millis) { sself->GetDateTime(time, year, month, day, hour, minute, second, millis); } +extern "C" int vtk_time_point_utility_get_year(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetYear(time); } +extern "C" int vtk_time_point_utility_get_month(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetMonth(time); } +extern "C" int vtk_time_point_utility_get_day(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetDay(time); } +extern "C" int vtk_time_point_utility_get_hour(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetHour(time); } +extern "C" int vtk_time_point_utility_get_minute(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetMinute(time); } +extern "C" int vtk_time_point_utility_get_second(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetSecond(time); } +extern "C" int vtk_time_point_utility_get_millisecond(vtkTimePointUtility* sself, unsigned long long time) { return sself->GetMillisecond(time); } +extern "C" const char* vtk_time_point_utility_time_point_to_iso_8601(vtkTimePointUtility* sself, unsigned long long p0, int format) { return sself->TimePointToISO8601(p0, format); } +extern "C" vtkTypeFloat32Array * vtkTypeFloat32Array_new () {return vtkTypeFloat32Array :: New () ;} +extern "C" void vtkTypeFloat32Array_destructor (vtkTypeFloat32Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeFloat64Array * vtkTypeFloat64Array_new () {return vtkTypeFloat64Array :: New () ;} +extern "C" void vtkTypeFloat64Array_destructor (vtkTypeFloat64Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeInt16Array * vtkTypeInt16Array_new () {return vtkTypeInt16Array :: New () ;} +extern "C" void vtkTypeInt16Array_destructor (vtkTypeInt16Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeInt32Array * vtkTypeInt32Array_new () {return vtkTypeInt32Array :: New () ;} +extern "C" void vtkTypeInt32Array_destructor (vtkTypeInt32Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeInt64Array * vtkTypeInt64Array_new () {return vtkTypeInt64Array :: New () ;} +extern "C" void vtkTypeInt64Array_destructor (vtkTypeInt64Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeInt8Array * vtkTypeInt8Array_new () {return vtkTypeInt8Array :: New () ;} +extern "C" void vtkTypeInt8Array_destructor (vtkTypeInt8Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeUInt16Array * vtkTypeUInt16Array_new () {return vtkTypeUInt16Array :: New () ;} +extern "C" void vtkTypeUInt16Array_destructor (vtkTypeUInt16Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeUInt32Array * vtkTypeUInt32Array_new () {return vtkTypeUInt32Array :: New () ;} +extern "C" void vtkTypeUInt32Array_destructor (vtkTypeUInt32Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeUInt64Array * vtkTypeUInt64Array_new () {return vtkTypeUInt64Array :: New () ;} +extern "C" void vtkTypeUInt64Array_destructor (vtkTypeUInt64Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkTypeUInt8Array * vtkTypeUInt8Array_new () {return vtkTypeUInt8Array :: New () ;} +extern "C" void vtkTypeUInt8Array_destructor (vtkTypeUInt8Array * sself) {sself -> Delete () ; return ;} +extern "C" vtkUnicodeStringArray * vtkUnicodeStringArray_new () {return vtkUnicodeStringArray :: New () ;} +extern "C" void vtkUnicodeStringArray_destructor (vtkUnicodeStringArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_unicode_string_array_allocate(vtkUnicodeStringArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_unicode_string_array_initialize(vtkUnicodeStringArray* sself) { sself->Initialize(); } +extern "C" int vtk_unicode_string_array_get_data_type(vtkUnicodeStringArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_unicode_string_array_get_data_type_size(vtkUnicodeStringArray* sself) { return sself->GetDataTypeSize(); } +extern "C" int vtk_unicode_string_array_get_element_component_size(vtkUnicodeStringArray* sself) { return sself->GetElementComponentSize(); } +extern "C" void vtk_unicode_string_array_set_number_of_tuples(vtkUnicodeStringArray* sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" void* vtk_unicode_string_array_get_void_pointer(vtkUnicodeStringArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_unicode_string_array_squeeze(vtkUnicodeStringArray* sself) { sself->Squeeze(); } +extern "C" int vtk_unicode_string_array_resize(vtkUnicodeStringArray* sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" void vtk_unicode_string_array_set_void_array(vtkUnicodeStringArray* sself, void* array, long long size, int save) { sself->SetVoidArray(array, size, save); } +extern "C" unsigned long vtk_unicode_string_array_get_actual_memory_size(vtkUnicodeStringArray* sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_unicode_string_array_is_numeric(vtkUnicodeStringArray* sself) { return sself->IsNumeric(); } +extern "C" void vtk_unicode_string_array_data_changed(vtkUnicodeStringArray* sself) { sself->DataChanged(); } +extern "C" void vtk_unicode_string_array_clear_lookup(vtkUnicodeStringArray* sself) { sself->ClearLookup(); } +extern "C" void vtk_unicode_string_array_insert_next_utf_8_value(vtkUnicodeStringArray* sself, const char* p0) { sself->InsertNextUTF8Value(p0); } +extern "C" void vtk_unicode_string_array_set_utf_8_value(vtkUnicodeStringArray* sself, long long i, const char* p1) { sself->SetUTF8Value(i, p1); } +extern "C" const char* vtk_unicode_string_array_get_utf_8_value(vtkUnicodeStringArray* sself, long long i) { return sself->GetUTF8Value(i); } +extern "C" vtkUnsignedCharArray * vtkUnsignedCharArray_new () {return vtkUnsignedCharArray :: New () ;} +extern "C" void vtkUnsignedCharArray_destructor (vtkUnsignedCharArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_unsigned_char_array_get_data_type(vtkUnsignedCharArray* sself) { return sself->GetDataType(); } +extern "C" unsigned char vtk_unsigned_char_array_get_value(vtkUnsignedCharArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_char_array_set_value(vtkUnsignedCharArray* sself, long long id, unsigned char value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_char_array_set_number_of_values(vtkUnsignedCharArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_char_array_insert_value(vtkUnsignedCharArray* sself, long long id, unsigned char f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_char_array_insert_next_value(vtkUnsignedCharArray* sself, unsigned char f) { return sself->InsertNextValue(f); } +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_min(vtkUnsignedCharArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned char vtk_unsigned_char_array_get_data_type_value_max(vtkUnsignedCharArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkUnsignedIntArray * vtkUnsignedIntArray_new () {return vtkUnsignedIntArray :: New () ;} +extern "C" void vtkUnsignedIntArray_destructor (vtkUnsignedIntArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_unsigned_int_array_get_data_type(vtkUnsignedIntArray* sself) { return sself->GetDataType(); } +extern "C" unsigned int vtk_unsigned_int_array_get_value(vtkUnsignedIntArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_int_array_set_value(vtkUnsignedIntArray* sself, long long id, unsigned int value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_int_array_set_number_of_values(vtkUnsignedIntArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_int_array_insert_value(vtkUnsignedIntArray* sself, long long id, unsigned int f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_int_array_insert_next_value(vtkUnsignedIntArray* sself, unsigned int f) { return sself->InsertNextValue(f); } +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_min(vtkUnsignedIntArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned int vtk_unsigned_int_array_get_data_type_value_max(vtkUnsignedIntArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkUnsignedLongArray * vtkUnsignedLongArray_new () {return vtkUnsignedLongArray :: New () ;} +extern "C" void vtkUnsignedLongArray_destructor (vtkUnsignedLongArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_unsigned_long_array_get_data_type(vtkUnsignedLongArray* sself) { return sself->GetDataType(); } +extern "C" unsigned long vtk_unsigned_long_array_get_value(vtkUnsignedLongArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_long_array_set_value(vtkUnsignedLongArray* sself, long long id, unsigned long value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_long_array_set_number_of_values(vtkUnsignedLongArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_long_array_insert_value(vtkUnsignedLongArray* sself, long long id, unsigned long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_long_array_insert_next_value(vtkUnsignedLongArray* sself, unsigned long f) { return sself->InsertNextValue(f); } +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_min(vtkUnsignedLongArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned long vtk_unsigned_long_array_get_data_type_value_max(vtkUnsignedLongArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkUnsignedLongLongArray * vtkUnsignedLongLongArray_new () {return vtkUnsignedLongLongArray :: New () ;} +extern "C" void vtkUnsignedLongLongArray_destructor (vtkUnsignedLongLongArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_unsigned_long_long_array_get_data_type(vtkUnsignedLongLongArray* sself) { return sself->GetDataType(); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_value(vtkUnsignedLongLongArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_long_long_array_set_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_long_long_array_set_number_of_values(vtkUnsignedLongLongArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_long_long_array_insert_value(vtkUnsignedLongLongArray* sself, long long id, unsigned long long f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_long_long_array_insert_next_value(vtkUnsignedLongLongArray* sself, unsigned long long f) { return sself->InsertNextValue(f); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_min(vtkUnsignedLongLongArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned long long vtk_unsigned_long_long_array_get_data_type_value_max(vtkUnsignedLongLongArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkUnsignedShortArray * vtkUnsignedShortArray_new () {return vtkUnsignedShortArray :: New () ;} +extern "C" void vtkUnsignedShortArray_destructor (vtkUnsignedShortArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_unsigned_short_array_get_data_type(vtkUnsignedShortArray* sself) { return sself->GetDataType(); } +extern "C" unsigned short vtk_unsigned_short_array_get_value(vtkUnsignedShortArray* sself, long long id) { return sself->GetValue(id); } +extern "C" void vtk_unsigned_short_array_set_value(vtkUnsignedShortArray* sself, long long id, unsigned short value) { sself->SetValue(id, value); } +extern "C" bool vtk_unsigned_short_array_set_number_of_values(vtkUnsignedShortArray* sself, long long number) { return sself->SetNumberOfValues(number); } +extern "C" void vtk_unsigned_short_array_insert_value(vtkUnsignedShortArray* sself, long long id, unsigned short f) { sself->InsertValue(id, f); } +extern "C" long long vtk_unsigned_short_array_insert_next_value(vtkUnsignedShortArray* sself, unsigned short f) { return sself->InsertNextValue(f); } +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_min(vtkUnsignedShortArray* sself) { return sself->GetDataTypeValueMin(); } +extern "C" unsigned short vtk_unsigned_short_array_get_data_type_value_max(vtkUnsignedShortArray* sself) { return sself->GetDataTypeValueMax(); } +extern "C" vtkVariantArray * vtkVariantArray_new () {return vtkVariantArray :: New () ;} +extern "C" void vtkVariantArray_destructor (vtkVariantArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_variant_array_allocate(vtkVariantArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_variant_array_initialize(vtkVariantArray* sself) { sself->Initialize(); } +extern "C" int vtk_variant_array_get_data_type(vtkVariantArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_variant_array_get_data_type_size(vtkVariantArray* sself) { return sself->GetDataTypeSize(); } +extern "C" int vtk_variant_array_get_element_component_size(vtkVariantArray* sself) { return sself->GetElementComponentSize(); } +extern "C" void vtk_variant_array_set_number_of_tuples(vtkVariantArray* sself, long long number) { sself->SetNumberOfTuples(number); } +extern "C" void* vtk_variant_array_get_void_pointer(vtkVariantArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_variant_array_squeeze(vtkVariantArray* sself) { sself->Squeeze(); } +extern "C" int vtk_variant_array_resize(vtkVariantArray* sself, long long numTuples) { return sself->Resize(numTuples); } +extern "C" void vtk_variant_array_set_void_array(vtkVariantArray* sself, void* arr, long long size, int save) { sself->SetVoidArray(arr, size, save); } +extern "C" unsigned long vtk_variant_array_get_actual_memory_size(vtkVariantArray* sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_variant_array_is_numeric(vtkVariantArray* sself) { return sself->IsNumeric(); } +extern "C" long long vtk_variant_array_get_number_of_values(vtkVariantArray* sself) { return sself->GetNumberOfValues(); } +extern "C" void vtk_variant_array_data_changed(vtkVariantArray* sself) { sself->DataChanged(); } +extern "C" void vtk_variant_array_data_element_changed(vtkVariantArray* sself, long long id) { sself->DataElementChanged(id); } +extern "C" void vtk_variant_array_clear_lookup(vtkVariantArray* sself) { sself->ClearLookup(); } +extern "C" vtkVersion * vtkVersion_new () {return vtkVersion :: New () ;} +extern "C" void vtkVersion_destructor (vtkVersion * sself) {sself -> Delete () ; return ;} +extern "C" const char* vtk_version_get_vtk_version(vtkVersion* sself) { return sself->GetVTKVersion(); } +extern "C" const char* vtk_version_get_vtk_version_full(vtkVersion* sself) { return sself->GetVTKVersionFull(); } +extern "C" int vtk_version_get_vtk_major_version(vtkVersion* sself) { return sself->GetVTKMajorVersion(); } +extern "C" int vtk_version_get_vtk_minor_version(vtkVersion* sself) { return sself->GetVTKMinorVersion(); } +extern "C" int vtk_version_get_vtk_build_version(vtkVersion* sself) { return sself->GetVTKBuildVersion(); } +extern "C" const char* vtk_version_get_vtk_source_version(vtkVersion* sself) { return sself->GetVTKSourceVersion(); } +extern "C" vtkVoidArray * vtkVoidArray_new () {return vtkVoidArray :: New () ;} +extern "C" void vtkVoidArray_destructor (vtkVoidArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_void_array_allocate(vtkVoidArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_void_array_initialize(vtkVoidArray* sself) { sself->Initialize(); } +extern "C" int vtk_void_array_get_data_type(vtkVoidArray* sself) { return sself->GetDataType(); } +extern "C" int vtk_void_array_get_data_type_size(vtkVoidArray* sself) { return sself->GetDataTypeSize(); } +extern "C" void vtk_void_array_set_number_of_pointers(vtkVoidArray* sself, long long number) { sself->SetNumberOfPointers(number); } +extern "C" long long vtk_void_array_get_number_of_pointers(vtkVoidArray* sself) { return sself->GetNumberOfPointers(); } +extern "C" void* vtk_void_array_get_void_pointer(vtkVoidArray* sself, long long id) { return sself->GetVoidPointer(id); } +extern "C" void vtk_void_array_set_void_pointer(vtkVoidArray* sself, long long id, void* ptr) { sself->SetVoidPointer(id, ptr); } +extern "C" void vtk_void_array_insert_void_pointer(vtkVoidArray* sself, long long i, void* ptr) { sself->InsertVoidPointer(i, ptr); } +extern "C" long long vtk_void_array_insert_next_void_pointer(vtkVoidArray* sself, void* tuple) { return sself->InsertNextVoidPointer(tuple); } +extern "C" void vtk_void_array_reset(vtkVoidArray* sself) { sself->Reset(); } +extern "C" void vtk_void_array_squeeze(vtkVoidArray* sself) { sself->Squeeze(); } +extern "C" vtkWeakReference * vtkWeakReference_new () {return vtkWeakReference :: New () ;} +extern "C" void vtkWeakReference_destructor (vtkWeakReference * sself) {sself -> Delete () ; return ;} +extern "C" vtkXMLFileOutputWindow * vtkXMLFileOutputWindow_new () {return vtkXMLFileOutputWindow :: New () ;} +extern "C" void vtkXMLFileOutputWindow_destructor (vtkXMLFileOutputWindow * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_xml_file_output_window_display_text(vtkXMLFileOutputWindow* sself, const char* p0) { sself->DisplayText(p0); } +extern "C" void vtk_xml_file_output_window_display_tag(vtkXMLFileOutputWindow* sself, const char* p0) { sself->DisplayTag(p0); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp index 73693be..9996bda 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_data_model.cpp @@ -47,7 +47,6 @@ #include #include #include -#include #include #include #include @@ -63,7 +62,6 @@ #include #include #include -#include #include #include #include @@ -233,7 +231,6 @@ #include #include #include -#include #include #include #include @@ -285,573 +282,1702 @@ #include // Implement declared functions -extern "C" vtkNew < vtkAMRDataInternals > vtkAMRDataInternals_new () {return vtkNew < vtkAMRDataInternals > () ;} -extern "C" void vtkAMRDataInternals_destructor (vtkNew < vtkAMRDataInternals > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAMRDataInternals_get_ptr (vtkNew < vtkAMRDataInternals > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkAdjacentVertexIterator > vtkAdjacentVertexIterator_new () {return vtkNew < vtkAdjacentVertexIterator > () ;} -extern "C" void vtkAdjacentVertexIterator_destructor (vtkNew < vtkAdjacentVertexIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAdjacentVertexIterator_get_ptr (vtkNew < vtkAdjacentVertexIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkAnimationScene > vtkAnimationScene_new () {return vtkNew < vtkAnimationScene > () ;} -extern "C" void vtkAnimationScene_destructor (vtkNew < vtkAnimationScene > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnimationScene_get_ptr (vtkNew < vtkAnimationScene > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkAnnotation > vtkAnnotation_new () {return vtkNew < vtkAnnotation > () ;} -extern "C" void vtkAnnotation_destructor (vtkNew < vtkAnnotation > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnnotation_get_ptr (vtkNew < vtkAnnotation > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkAnnotationLayers > vtkAnnotationLayers_new () {return vtkNew < vtkAnnotationLayers > () ;} -extern "C" void vtkAnnotationLayers_destructor (vtkNew < vtkAnnotationLayers > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnnotationLayers_get_ptr (vtkNew < vtkAnnotationLayers > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkArrayData > vtkArrayData_new () {return vtkNew < vtkArrayData > () ;} -extern "C" void vtkArrayData_destructor (vtkNew < vtkArrayData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkArrayData_get_ptr (vtkNew < vtkArrayData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkAttributesErrorMetric > vtkAttributesErrorMetric_new () {return vtkNew < vtkAttributesErrorMetric > () ;} -extern "C" void vtkAttributesErrorMetric_destructor (vtkNew < vtkAttributesErrorMetric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAttributesErrorMetric_get_ptr (vtkNew < vtkAttributesErrorMetric > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBSPCuts > vtkBSPCuts_new () {return vtkNew < vtkBSPCuts > () ;} -extern "C" void vtkBSPCuts_destructor (vtkNew < vtkBSPCuts > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBSPCuts_get_ptr (vtkNew < vtkBSPCuts > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBSPIntersections > vtkBSPIntersections_new () {return vtkNew < vtkBSPIntersections > () ;} -extern "C" void vtkBSPIntersections_destructor (vtkNew < vtkBSPIntersections > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBSPIntersections_get_ptr (vtkNew < vtkBSPIntersections > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBezierCurve > vtkBezierCurve_new () {return vtkNew < vtkBezierCurve > () ;} -extern "C" void vtkBezierCurve_destructor (vtkNew < vtkBezierCurve > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierCurve_get_ptr (vtkNew < vtkBezierCurve > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBezierHexahedron > vtkBezierHexahedron_new () {return vtkNew < vtkBezierHexahedron > () ;} -extern "C" void vtkBezierHexahedron_destructor (vtkNew < vtkBezierHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierHexahedron_get_ptr (vtkNew < vtkBezierHexahedron > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBezierInterpolation > vtkBezierInterpolation_new () {return vtkNew < vtkBezierInterpolation > () ;} -extern "C" void vtkBezierInterpolation_destructor (vtkNew < vtkBezierInterpolation > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierInterpolation_get_ptr (vtkNew < vtkBezierInterpolation > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBezierQuadrilateral > vtkBezierQuadrilateral_new () {return vtkNew < vtkBezierQuadrilateral > () ;} -extern "C" void vtkBezierQuadrilateral_destructor (vtkNew < vtkBezierQuadrilateral > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierQuadrilateral_get_ptr (vtkNew < vtkBezierQuadrilateral > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBezierTetra > vtkBezierTetra_new () {return vtkNew < vtkBezierTetra > () ;} -extern "C" void vtkBezierTetra_destructor (vtkNew < vtkBezierTetra > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierTetra_get_ptr (vtkNew < vtkBezierTetra > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBezierTriangle > vtkBezierTriangle_new () {return vtkNew < vtkBezierTriangle > () ;} -extern "C" void vtkBezierTriangle_destructor (vtkNew < vtkBezierTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierTriangle_get_ptr (vtkNew < vtkBezierTriangle > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBezierWedge > vtkBezierWedge_new () {return vtkNew < vtkBezierWedge > () ;} -extern "C" void vtkBezierWedge_destructor (vtkNew < vtkBezierWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBezierWedge_get_ptr (vtkNew < vtkBezierWedge > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBiQuadraticQuad > vtkBiQuadraticQuad_new () {return vtkNew < vtkBiQuadraticQuad > () ;} -extern "C" void vtkBiQuadraticQuad_destructor (vtkNew < vtkBiQuadraticQuad > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBiQuadraticQuad_get_ptr (vtkNew < vtkBiQuadraticQuad > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBiQuadraticQuadraticHexahedron > vtkBiQuadraticQuadraticHexahedron_new () {return vtkNew < vtkBiQuadraticQuadraticHexahedron > () ;} -extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBiQuadraticQuadraticHexahedron_get_ptr (vtkNew < vtkBiQuadraticQuadraticHexahedron > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBiQuadraticQuadraticWedge > vtkBiQuadraticQuadraticWedge_new () {return vtkNew < vtkBiQuadraticQuadraticWedge > () ;} -extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkNew < vtkBiQuadraticQuadraticWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBiQuadraticQuadraticWedge_get_ptr (vtkNew < vtkBiQuadraticQuadraticWedge > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBiQuadraticTriangle > vtkBiQuadraticTriangle_new () {return vtkNew < vtkBiQuadraticTriangle > () ;} -extern "C" void vtkBiQuadraticTriangle_destructor (vtkNew < vtkBiQuadraticTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBiQuadraticTriangle_get_ptr (vtkNew < vtkBiQuadraticTriangle > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkBox > vtkBox_new () {return vtkNew < vtkBox > () ;} -extern "C" void vtkBox_destructor (vtkNew < vtkBox > sself) {sself . Reset () ; return ;} -extern "C" void * vtkBox_get_ptr (vtkNew < vtkBox > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellArray > vtkCellArray_new () {return vtkNew < vtkCellArray > () ;} -extern "C" void vtkCellArray_destructor (vtkNew < vtkCellArray > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellArray_get_ptr (vtkNew < vtkCellArray > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellArrayIterator > vtkCellArrayIterator_new () {return vtkNew < vtkCellArrayIterator > () ;} -extern "C" void vtkCellArrayIterator_destructor (vtkNew < vtkCellArrayIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellArrayIterator_get_ptr (vtkNew < vtkCellArrayIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellData > vtkCellData_new () {return vtkNew < vtkCellData > () ;} -extern "C" void vtkCellData_destructor (vtkNew < vtkCellData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellData_get_ptr (vtkNew < vtkCellData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellLinks > vtkCellLinks_new () {return vtkNew < vtkCellLinks > () ;} -extern "C" void vtkCellLinks_destructor (vtkNew < vtkCellLinks > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellLinks_get_ptr (vtkNew < vtkCellLinks > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellLocator > vtkCellLocator_new () {return vtkNew < vtkCellLocator > () ;} -extern "C" void vtkCellLocator_destructor (vtkNew < vtkCellLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellLocator_get_ptr (vtkNew < vtkCellLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellLocatorStrategy > vtkCellLocatorStrategy_new () {return vtkNew < vtkCellLocatorStrategy > () ;} -extern "C" void vtkCellLocatorStrategy_destructor (vtkNew < vtkCellLocatorStrategy > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellLocatorStrategy_get_ptr (vtkNew < vtkCellLocatorStrategy > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellTreeLocator > vtkCellTreeLocator_new () {return vtkNew < vtkCellTreeLocator > () ;} -extern "C" void vtkCellTreeLocator_destructor (vtkNew < vtkCellTreeLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellTreeLocator_get_ptr (vtkNew < vtkCellTreeLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCellTypes > vtkCellTypes_new () {return vtkNew < vtkCellTypes > () ;} -extern "C" void vtkCellTypes_destructor (vtkNew < vtkCellTypes > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCellTypes_get_ptr (vtkNew < vtkCellTypes > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkClosestNPointsStrategy > vtkClosestNPointsStrategy_new () {return vtkNew < vtkClosestNPointsStrategy > () ;} -extern "C" void vtkClosestNPointsStrategy_destructor (vtkNew < vtkClosestNPointsStrategy > sself) {sself . Reset () ; return ;} -extern "C" void * vtkClosestNPointsStrategy_get_ptr (vtkNew < vtkClosestNPointsStrategy > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkClosestPointStrategy > vtkClosestPointStrategy_new () {return vtkNew < vtkClosestPointStrategy > () ;} -extern "C" void vtkClosestPointStrategy_destructor (vtkNew < vtkClosestPointStrategy > sself) {sself . Reset () ; return ;} -extern "C" void * vtkClosestPointStrategy_get_ptr (vtkNew < vtkClosestPointStrategy > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCone > vtkCone_new () {return vtkNew < vtkCone > () ;} -extern "C" void vtkCone_destructor (vtkNew < vtkCone > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCone_get_ptr (vtkNew < vtkCone > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkConvexPointSet > vtkConvexPointSet_new () {return vtkNew < vtkConvexPointSet > () ;} -extern "C" void vtkConvexPointSet_destructor (vtkNew < vtkConvexPointSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkConvexPointSet_get_ptr (vtkNew < vtkConvexPointSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCoordinateFrame > vtkCoordinateFrame_new () {return vtkNew < vtkCoordinateFrame > () ;} -extern "C" void vtkCoordinateFrame_destructor (vtkNew < vtkCoordinateFrame > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCoordinateFrame_get_ptr (vtkNew < vtkCoordinateFrame > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCubicLine > vtkCubicLine_new () {return vtkNew < vtkCubicLine > () ;} -extern "C" void vtkCubicLine_destructor (vtkNew < vtkCubicLine > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCubicLine_get_ptr (vtkNew < vtkCubicLine > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCylinder > vtkCylinder_new () {return vtkNew < vtkCylinder > () ;} -extern "C" void vtkCylinder_destructor (vtkNew < vtkCylinder > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCylinder_get_ptr (vtkNew < vtkCylinder > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataAssembly > vtkDataAssembly_new () {return vtkNew < vtkDataAssembly > () ;} -extern "C" void vtkDataAssembly_destructor (vtkNew < vtkDataAssembly > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataAssembly_get_ptr (vtkNew < vtkDataAssembly > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataAssemblyUtilities > vtkDataAssemblyUtilities_new () {return vtkNew < vtkDataAssemblyUtilities > () ;} -extern "C" void vtkDataAssemblyUtilities_destructor (vtkNew < vtkDataAssemblyUtilities > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataAssemblyUtilities_get_ptr (vtkNew < vtkDataAssemblyUtilities > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataObject > vtkDataObject_new () {return vtkNew < vtkDataObject > () ;} -extern "C" void vtkDataObject_destructor (vtkNew < vtkDataObject > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObject_get_ptr (vtkNew < vtkDataObject > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataObjectCollection > vtkDataObjectCollection_new () {return vtkNew < vtkDataObjectCollection > () ;} -extern "C" void vtkDataObjectCollection_destructor (vtkNew < vtkDataObjectCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObjectCollection_get_ptr (vtkNew < vtkDataObjectCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataObjectTreeIterator > vtkDataObjectTreeIterator_new () {return vtkNew < vtkDataObjectTreeIterator > () ;} -extern "C" void vtkDataObjectTreeIterator_destructor (vtkNew < vtkDataObjectTreeIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObjectTreeIterator_get_ptr (vtkNew < vtkDataObjectTreeIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataObjectTypes > vtkDataObjectTypes_new () {return vtkNew < vtkDataObjectTypes > () ;} -extern "C" void vtkDataObjectTypes_destructor (vtkNew < vtkDataObjectTypes > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObjectTypes_get_ptr (vtkNew < vtkDataObjectTypes > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataSetAttributes > vtkDataSetAttributes_new () {return vtkNew < vtkDataSetAttributes > () ;} -extern "C" void vtkDataSetAttributes_destructor (vtkNew < vtkDataSetAttributes > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataSetAttributes_get_ptr (vtkNew < vtkDataSetAttributes > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataSetCellIterator > vtkDataSetCellIterator_new () {return vtkNew < vtkDataSetCellIterator > () ;} -extern "C" void vtkDataSetCellIterator_destructor (vtkNew < vtkDataSetCellIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataSetCellIterator_get_ptr (vtkNew < vtkDataSetCellIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataSetCollection > vtkDataSetCollection_new () {return vtkNew < vtkDataSetCollection > () ;} -extern "C" void vtkDataSetCollection_destructor (vtkNew < vtkDataSetCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataSetCollection_get_ptr (vtkNew < vtkDataSetCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDirectedAcyclicGraph > vtkDirectedAcyclicGraph_new () {return vtkNew < vtkDirectedAcyclicGraph > () ;} -extern "C" void vtkDirectedAcyclicGraph_destructor (vtkNew < vtkDirectedAcyclicGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDirectedAcyclicGraph_get_ptr (vtkNew < vtkDirectedAcyclicGraph > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDirectedGraph > vtkDirectedGraph_new () {return vtkNew < vtkDirectedGraph > () ;} -extern "C" void vtkDirectedGraph_destructor (vtkNew < vtkDirectedGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDirectedGraph_get_ptr (vtkNew < vtkDirectedGraph > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEdgeListIterator > vtkEdgeListIterator_new () {return vtkNew < vtkEdgeListIterator > () ;} -extern "C" void vtkEdgeListIterator_destructor (vtkNew < vtkEdgeListIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEdgeListIterator_get_ptr (vtkNew < vtkEdgeListIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEdgeTable > vtkEdgeTable_new () {return vtkNew < vtkEdgeTable > () ;} -extern "C" void vtkEdgeTable_destructor (vtkNew < vtkEdgeTable > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEdgeTable_get_ptr (vtkNew < vtkEdgeTable > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEmptyCell > vtkEmptyCell_new () {return vtkNew < vtkEmptyCell > () ;} -extern "C" void vtkEmptyCell_destructor (vtkNew < vtkEmptyCell > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEmptyCell_get_ptr (vtkNew < vtkEmptyCell > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExplicitStructuredGrid > vtkExplicitStructuredGrid_new () {return vtkNew < vtkExplicitStructuredGrid > () ;} -extern "C" void vtkExplicitStructuredGrid_destructor (vtkNew < vtkExplicitStructuredGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExplicitStructuredGrid_get_ptr (vtkNew < vtkExplicitStructuredGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExtractStructuredGridHelper > vtkExtractStructuredGridHelper_new () {return vtkNew < vtkExtractStructuredGridHelper > () ;} -extern "C" void vtkExtractStructuredGridHelper_destructor (vtkNew < vtkExtractStructuredGridHelper > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExtractStructuredGridHelper_get_ptr (vtkNew < vtkExtractStructuredGridHelper > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkFieldData > vtkFieldData_new () {return vtkNew < vtkFieldData > () ;} -extern "C" void vtkFieldData_destructor (vtkNew < vtkFieldData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFieldData_get_ptr (vtkNew < vtkFieldData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGenericAttributeCollection > vtkGenericAttributeCollection_new () {return vtkNew < vtkGenericAttributeCollection > () ;} -extern "C" void vtkGenericAttributeCollection_destructor (vtkNew < vtkGenericAttributeCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGenericAttributeCollection_get_ptr (vtkNew < vtkGenericAttributeCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGenericCell > vtkGenericCell_new () {return vtkNew < vtkGenericCell > () ;} -extern "C" void vtkGenericCell_destructor (vtkNew < vtkGenericCell > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGenericCell_get_ptr (vtkNew < vtkGenericCell > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGenericEdgeTable > vtkGenericEdgeTable_new () {return vtkNew < vtkGenericEdgeTable > () ;} -extern "C" void vtkGenericEdgeTable_destructor (vtkNew < vtkGenericEdgeTable > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGenericEdgeTable_get_ptr (vtkNew < vtkGenericEdgeTable > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGenericInterpolatedVelocityField > vtkGenericInterpolatedVelocityField_new () {return vtkNew < vtkGenericInterpolatedVelocityField > () ;} -extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkNew < vtkGenericInterpolatedVelocityField > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGenericInterpolatedVelocityField_get_ptr (vtkNew < vtkGenericInterpolatedVelocityField > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGeometricErrorMetric > vtkGeometricErrorMetric_new () {return vtkNew < vtkGeometricErrorMetric > () ;} -extern "C" void vtkGeometricErrorMetric_destructor (vtkNew < vtkGeometricErrorMetric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGeometricErrorMetric_get_ptr (vtkNew < vtkGeometricErrorMetric > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGraphEdge > vtkGraphEdge_new () {return vtkNew < vtkGraphEdge > () ;} -extern "C" void vtkGraphEdge_destructor (vtkNew < vtkGraphEdge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGraphEdge_get_ptr (vtkNew < vtkGraphEdge > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGraphInternals > vtkGraphInternals_new () {return vtkNew < vtkGraphInternals > () ;} -extern "C" void vtkGraphInternals_destructor (vtkNew < vtkGraphInternals > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGraphInternals_get_ptr (vtkNew < vtkGraphInternals > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHexagonalPrism > vtkHexagonalPrism_new () {return vtkNew < vtkHexagonalPrism > () ;} -extern "C" void vtkHexagonalPrism_destructor (vtkNew < vtkHexagonalPrism > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHexagonalPrism_get_ptr (vtkNew < vtkHexagonalPrism > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHexahedron > vtkHexahedron_new () {return vtkNew < vtkHexahedron > () ;} -extern "C" void vtkHexahedron_destructor (vtkNew < vtkHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHexahedron_get_ptr (vtkNew < vtkHexahedron > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHierarchicalBoxDataIterator > vtkHierarchicalBoxDataIterator_new () {return vtkNew < vtkHierarchicalBoxDataIterator > () ;} -extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkNew < vtkHierarchicalBoxDataIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHierarchicalBoxDataIterator_get_ptr (vtkNew < vtkHierarchicalBoxDataIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHierarchicalBoxDataSet > vtkHierarchicalBoxDataSet_new () {return vtkNew < vtkHierarchicalBoxDataSet > () ;} -extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkNew < vtkHierarchicalBoxDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHierarchicalBoxDataSet_get_ptr (vtkNew < vtkHierarchicalBoxDataSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGrid > vtkHyperTreeGrid_new () {return vtkNew < vtkHyperTreeGrid > () ;} -extern "C" void vtkHyperTreeGrid_destructor (vtkNew < vtkHyperTreeGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGrid_get_ptr (vtkNew < vtkHyperTreeGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedCursor > vtkHyperTreeGridNonOrientedCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedCursor > () ;} -extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedCursor > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > vtkHyperTreeGridNonOrientedGeometryCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > () ;} -extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedGeometryCursor > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > vtkHyperTreeGridNonOrientedMooreSuperCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > () ;} -extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursor > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () {return vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > () ;} -extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedMooreSuperCursorLight > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () {return vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > () ;} -extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursor > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () {return vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > () ;} -extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr (vtkNew < vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridOrientedCursor > vtkHyperTreeGridOrientedCursor_new () {return vtkNew < vtkHyperTreeGridOrientedCursor > () ;} -extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkNew < vtkHyperTreeGridOrientedCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridOrientedCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedCursor > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHyperTreeGridOrientedGeometryCursor > vtkHyperTreeGridOrientedGeometryCursor_new () {return vtkNew < vtkHyperTreeGridOrientedGeometryCursor > () ;} -extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHyperTreeGridOrientedGeometryCursor_get_ptr (vtkNew < vtkHyperTreeGridOrientedGeometryCursor > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImageData > vtkImageData_new () {return vtkNew < vtkImageData > () ;} -extern "C" void vtkImageData_destructor (vtkNew < vtkImageData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImageData_get_ptr (vtkNew < vtkImageData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImageTransform > vtkImageTransform_new () {return vtkNew < vtkImageTransform > () ;} -extern "C" void vtkImageTransform_destructor (vtkNew < vtkImageTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImageTransform_get_ptr (vtkNew < vtkImageTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitBoolean > vtkImplicitBoolean_new () {return vtkNew < vtkImplicitBoolean > () ;} -extern "C" void vtkImplicitBoolean_destructor (vtkNew < vtkImplicitBoolean > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitBoolean_get_ptr (vtkNew < vtkImplicitBoolean > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitDataSet > vtkImplicitDataSet_new () {return vtkNew < vtkImplicitDataSet > () ;} -extern "C" void vtkImplicitDataSet_destructor (vtkNew < vtkImplicitDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitDataSet_get_ptr (vtkNew < vtkImplicitDataSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitFunctionCollection > vtkImplicitFunctionCollection_new () {return vtkNew < vtkImplicitFunctionCollection > () ;} -extern "C" void vtkImplicitFunctionCollection_destructor (vtkNew < vtkImplicitFunctionCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitFunctionCollection_get_ptr (vtkNew < vtkImplicitFunctionCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitHalo > vtkImplicitHalo_new () {return vtkNew < vtkImplicitHalo > () ;} -extern "C" void vtkImplicitHalo_destructor (vtkNew < vtkImplicitHalo > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitHalo_get_ptr (vtkNew < vtkImplicitHalo > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitSelectionLoop > vtkImplicitSelectionLoop_new () {return vtkNew < vtkImplicitSelectionLoop > () ;} -extern "C" void vtkImplicitSelectionLoop_destructor (vtkNew < vtkImplicitSelectionLoop > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitSelectionLoop_get_ptr (vtkNew < vtkImplicitSelectionLoop > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitSum > vtkImplicitSum_new () {return vtkNew < vtkImplicitSum > () ;} -extern "C" void vtkImplicitSum_destructor (vtkNew < vtkImplicitSum > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitSum_get_ptr (vtkNew < vtkImplicitSum > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitVolume > vtkImplicitVolume_new () {return vtkNew < vtkImplicitVolume > () ;} -extern "C" void vtkImplicitVolume_destructor (vtkNew < vtkImplicitVolume > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitVolume_get_ptr (vtkNew < vtkImplicitVolume > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImplicitWindowFunction > vtkImplicitWindowFunction_new () {return vtkNew < vtkImplicitWindowFunction > () ;} -extern "C" void vtkImplicitWindowFunction_destructor (vtkNew < vtkImplicitWindowFunction > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImplicitWindowFunction_get_ptr (vtkNew < vtkImplicitWindowFunction > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkInEdgeIterator > vtkInEdgeIterator_new () {return vtkNew < vtkInEdgeIterator > () ;} -extern "C" void vtkInEdgeIterator_destructor (vtkNew < vtkInEdgeIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkInEdgeIterator_get_ptr (vtkNew < vtkInEdgeIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkIncrementalOctreeNode > vtkIncrementalOctreeNode_new () {return vtkNew < vtkIncrementalOctreeNode > () ;} -extern "C" void vtkIncrementalOctreeNode_destructor (vtkNew < vtkIncrementalOctreeNode > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIncrementalOctreeNode_get_ptr (vtkNew < vtkIncrementalOctreeNode > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkIncrementalOctreePointLocator > vtkIncrementalOctreePointLocator_new () {return vtkNew < vtkIncrementalOctreePointLocator > () ;} -extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkNew < vtkIncrementalOctreePointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIncrementalOctreePointLocator_get_ptr (vtkNew < vtkIncrementalOctreePointLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkIterativeClosestPointTransform > vtkIterativeClosestPointTransform_new () {return vtkNew < vtkIterativeClosestPointTransform > () ;} -extern "C" void vtkIterativeClosestPointTransform_destructor (vtkNew < vtkIterativeClosestPointTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIterativeClosestPointTransform_get_ptr (vtkNew < vtkIterativeClosestPointTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkKdNode > vtkKdNode_new () {return vtkNew < vtkKdNode > () ;} -extern "C" void vtkKdNode_destructor (vtkNew < vtkKdNode > sself) {sself . Reset () ; return ;} -extern "C" void * vtkKdNode_get_ptr (vtkNew < vtkKdNode > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkKdTree > vtkKdTree_new () {return vtkNew < vtkKdTree > () ;} -extern "C" void vtkKdTree_destructor (vtkNew < vtkKdTree > sself) {sself . Reset () ; return ;} -extern "C" void * vtkKdTree_get_ptr (vtkNew < vtkKdTree > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkKdTreePointLocator > vtkKdTreePointLocator_new () {return vtkNew < vtkKdTreePointLocator > () ;} -extern "C" void vtkKdTreePointLocator_destructor (vtkNew < vtkKdTreePointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkKdTreePointLocator_get_ptr (vtkNew < vtkKdTreePointLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLagrangeCurve > vtkLagrangeCurve_new () {return vtkNew < vtkLagrangeCurve > () ;} -extern "C" void vtkLagrangeCurve_destructor (vtkNew < vtkLagrangeCurve > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeCurve_get_ptr (vtkNew < vtkLagrangeCurve > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLagrangeHexahedron > vtkLagrangeHexahedron_new () {return vtkNew < vtkLagrangeHexahedron > () ;} -extern "C" void vtkLagrangeHexahedron_destructor (vtkNew < vtkLagrangeHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeHexahedron_get_ptr (vtkNew < vtkLagrangeHexahedron > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLagrangeInterpolation > vtkLagrangeInterpolation_new () {return vtkNew < vtkLagrangeInterpolation > () ;} -extern "C" void vtkLagrangeInterpolation_destructor (vtkNew < vtkLagrangeInterpolation > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeInterpolation_get_ptr (vtkNew < vtkLagrangeInterpolation > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLagrangeQuadrilateral > vtkLagrangeQuadrilateral_new () {return vtkNew < vtkLagrangeQuadrilateral > () ;} -extern "C" void vtkLagrangeQuadrilateral_destructor (vtkNew < vtkLagrangeQuadrilateral > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeQuadrilateral_get_ptr (vtkNew < vtkLagrangeQuadrilateral > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLagrangeTetra > vtkLagrangeTetra_new () {return vtkNew < vtkLagrangeTetra > () ;} -extern "C" void vtkLagrangeTetra_destructor (vtkNew < vtkLagrangeTetra > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeTetra_get_ptr (vtkNew < vtkLagrangeTetra > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLagrangeTriangle > vtkLagrangeTriangle_new () {return vtkNew < vtkLagrangeTriangle > () ;} -extern "C" void vtkLagrangeTriangle_destructor (vtkNew < vtkLagrangeTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeTriangle_get_ptr (vtkNew < vtkLagrangeTriangle > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLagrangeWedge > vtkLagrangeWedge_new () {return vtkNew < vtkLagrangeWedge > () ;} -extern "C" void vtkLagrangeWedge_destructor (vtkNew < vtkLagrangeWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLagrangeWedge_get_ptr (vtkNew < vtkLagrangeWedge > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLine > vtkLine_new () {return vtkNew < vtkLine > () ;} -extern "C" void vtkLine_destructor (vtkNew < vtkLine > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLine_get_ptr (vtkNew < vtkLine > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMeanValueCoordinatesInterpolator > vtkMeanValueCoordinatesInterpolator_new () {return vtkNew < vtkMeanValueCoordinatesInterpolator > () ;} -extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMeanValueCoordinatesInterpolator_get_ptr (vtkNew < vtkMeanValueCoordinatesInterpolator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMergePoints > vtkMergePoints_new () {return vtkNew < vtkMergePoints > () ;} -extern "C" void vtkMergePoints_destructor (vtkNew < vtkMergePoints > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMergePoints_get_ptr (vtkNew < vtkMergePoints > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMolecule > vtkMolecule_new () {return vtkNew < vtkMolecule > () ;} -extern "C" void vtkMolecule_destructor (vtkNew < vtkMolecule > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMolecule_get_ptr (vtkNew < vtkMolecule > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMultiBlockDataSet > vtkMultiBlockDataSet_new () {return vtkNew < vtkMultiBlockDataSet > () ;} -extern "C" void vtkMultiBlockDataSet_destructor (vtkNew < vtkMultiBlockDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiBlockDataSet_get_ptr (vtkNew < vtkMultiBlockDataSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMultiPieceDataSet > vtkMultiPieceDataSet_new () {return vtkNew < vtkMultiPieceDataSet > () ;} -extern "C" void vtkMultiPieceDataSet_destructor (vtkNew < vtkMultiPieceDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiPieceDataSet_get_ptr (vtkNew < vtkMultiPieceDataSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMutableDirectedGraph > vtkMutableDirectedGraph_new () {return vtkNew < vtkMutableDirectedGraph > () ;} -extern "C" void vtkMutableDirectedGraph_destructor (vtkNew < vtkMutableDirectedGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMutableDirectedGraph_get_ptr (vtkNew < vtkMutableDirectedGraph > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMutableUndirectedGraph > vtkMutableUndirectedGraph_new () {return vtkNew < vtkMutableUndirectedGraph > () ;} -extern "C" void vtkMutableUndirectedGraph_destructor (vtkNew < vtkMutableUndirectedGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMutableUndirectedGraph_get_ptr (vtkNew < vtkMutableUndirectedGraph > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkNonMergingPointLocator > vtkNonMergingPointLocator_new () {return vtkNew < vtkNonMergingPointLocator > () ;} -extern "C" void vtkNonMergingPointLocator_destructor (vtkNew < vtkNonMergingPointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkNonMergingPointLocator_get_ptr (vtkNew < vtkNonMergingPointLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkNonOverlappingAMR > vtkNonOverlappingAMR_new () {return vtkNew < vtkNonOverlappingAMR > () ;} -extern "C" void vtkNonOverlappingAMR_destructor (vtkNew < vtkNonOverlappingAMR > sself) {sself . Reset () ; return ;} -extern "C" void * vtkNonOverlappingAMR_get_ptr (vtkNew < vtkNonOverlappingAMR > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOctreePointLocator > vtkOctreePointLocator_new () {return vtkNew < vtkOctreePointLocator > () ;} -extern "C" void vtkOctreePointLocator_destructor (vtkNew < vtkOctreePointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOctreePointLocator_get_ptr (vtkNew < vtkOctreePointLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOctreePointLocatorNode > vtkOctreePointLocatorNode_new () {return vtkNew < vtkOctreePointLocatorNode > () ;} -extern "C" void vtkOctreePointLocatorNode_destructor (vtkNew < vtkOctreePointLocatorNode > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOctreePointLocatorNode_get_ptr (vtkNew < vtkOctreePointLocatorNode > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOrderedTriangulator > vtkOrderedTriangulator_new () {return vtkNew < vtkOrderedTriangulator > () ;} -extern "C" void vtkOrderedTriangulator_destructor (vtkNew < vtkOrderedTriangulator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOrderedTriangulator_get_ptr (vtkNew < vtkOrderedTriangulator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOutEdgeIterator > vtkOutEdgeIterator_new () {return vtkNew < vtkOutEdgeIterator > () ;} -extern "C" void vtkOutEdgeIterator_destructor (vtkNew < vtkOutEdgeIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOutEdgeIterator_get_ptr (vtkNew < vtkOutEdgeIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOverlappingAMR > vtkOverlappingAMR_new () {return vtkNew < vtkOverlappingAMR > () ;} -extern "C" void vtkOverlappingAMR_destructor (vtkNew < vtkOverlappingAMR > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOverlappingAMR_get_ptr (vtkNew < vtkOverlappingAMR > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPartitionedDataSet > vtkPartitionedDataSet_new () {return vtkNew < vtkPartitionedDataSet > () ;} -extern "C" void vtkPartitionedDataSet_destructor (vtkNew < vtkPartitionedDataSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPartitionedDataSet_get_ptr (vtkNew < vtkPartitionedDataSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPartitionedDataSetCollection > vtkPartitionedDataSetCollection_new () {return vtkNew < vtkPartitionedDataSetCollection > () ;} -extern "C" void vtkPartitionedDataSetCollection_destructor (vtkNew < vtkPartitionedDataSetCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPartitionedDataSetCollection_get_ptr (vtkNew < vtkPartitionedDataSetCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPath > vtkPath_new () {return vtkNew < vtkPath > () ;} -extern "C" void vtkPath_destructor (vtkNew < vtkPath > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPath_get_ptr (vtkNew < vtkPath > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPentagonalPrism > vtkPentagonalPrism_new () {return vtkNew < vtkPentagonalPrism > () ;} -extern "C" void vtkPentagonalPrism_destructor (vtkNew < vtkPentagonalPrism > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPentagonalPrism_get_ptr (vtkNew < vtkPentagonalPrism > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPerlinNoise > vtkPerlinNoise_new () {return vtkNew < vtkPerlinNoise > () ;} -extern "C" void vtkPerlinNoise_destructor (vtkNew < vtkPerlinNoise > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPerlinNoise_get_ptr (vtkNew < vtkPerlinNoise > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPiecewiseFunction > vtkPiecewiseFunction_new () {return vtkNew < vtkPiecewiseFunction > () ;} -extern "C" void vtkPiecewiseFunction_destructor (vtkNew < vtkPiecewiseFunction > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPiecewiseFunction_get_ptr (vtkNew < vtkPiecewiseFunction > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPixel > vtkPixel_new () {return vtkNew < vtkPixel > () ;} -extern "C" void vtkPixel_destructor (vtkNew < vtkPixel > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPixel_get_ptr (vtkNew < vtkPixel > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPlane > vtkPlane_new () {return vtkNew < vtkPlane > () ;} -extern "C" void vtkPlane_destructor (vtkNew < vtkPlane > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPlane_get_ptr (vtkNew < vtkPlane > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPlaneCollection > vtkPlaneCollection_new () {return vtkNew < vtkPlaneCollection > () ;} -extern "C" void vtkPlaneCollection_destructor (vtkNew < vtkPlaneCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPlaneCollection_get_ptr (vtkNew < vtkPlaneCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPlanes > vtkPlanes_new () {return vtkNew < vtkPlanes > () ;} -extern "C" void vtkPlanes_destructor (vtkNew < vtkPlanes > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPlanes_get_ptr (vtkNew < vtkPlanes > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPlanesIntersection > vtkPlanesIntersection_new () {return vtkNew < vtkPlanesIntersection > () ;} -extern "C" void vtkPlanesIntersection_destructor (vtkNew < vtkPlanesIntersection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPlanesIntersection_get_ptr (vtkNew < vtkPlanesIntersection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPointData > vtkPointData_new () {return vtkNew < vtkPointData > () ;} -extern "C" void vtkPointData_destructor (vtkNew < vtkPointData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointData_get_ptr (vtkNew < vtkPointData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPointLocator > vtkPointLocator_new () {return vtkNew < vtkPointLocator > () ;} -extern "C" void vtkPointLocator_destructor (vtkNew < vtkPointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointLocator_get_ptr (vtkNew < vtkPointLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPointSet > vtkPointSet_new () {return vtkNew < vtkPointSet > () ;} -extern "C" void vtkPointSet_destructor (vtkNew < vtkPointSet > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointSet_get_ptr (vtkNew < vtkPointSet > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPointSetCellIterator > vtkPointSetCellIterator_new () {return vtkNew < vtkPointSetCellIterator > () ;} -extern "C" void vtkPointSetCellIterator_destructor (vtkNew < vtkPointSetCellIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointSetCellIterator_get_ptr (vtkNew < vtkPointSetCellIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPointsProjectedHull > vtkPointsProjectedHull_new () {return vtkNew < vtkPointsProjectedHull > () ;} -extern "C" void vtkPointsProjectedHull_destructor (vtkNew < vtkPointsProjectedHull > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointsProjectedHull_get_ptr (vtkNew < vtkPointsProjectedHull > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyData > vtkPolyData_new () {return vtkNew < vtkPolyData > () ;} -extern "C" void vtkPolyData_destructor (vtkNew < vtkPolyData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyData_get_ptr (vtkNew < vtkPolyData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyDataCollection > vtkPolyDataCollection_new () {return vtkNew < vtkPolyDataCollection > () ;} -extern "C" void vtkPolyDataCollection_destructor (vtkNew < vtkPolyDataCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyDataCollection_get_ptr (vtkNew < vtkPolyDataCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyLine > vtkPolyLine_new () {return vtkNew < vtkPolyLine > () ;} -extern "C" void vtkPolyLine_destructor (vtkNew < vtkPolyLine > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyLine_get_ptr (vtkNew < vtkPolyLine > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyPlane > vtkPolyPlane_new () {return vtkNew < vtkPolyPlane > () ;} -extern "C" void vtkPolyPlane_destructor (vtkNew < vtkPolyPlane > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyPlane_get_ptr (vtkNew < vtkPolyPlane > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyVertex > vtkPolyVertex_new () {return vtkNew < vtkPolyVertex > () ;} -extern "C" void vtkPolyVertex_destructor (vtkNew < vtkPolyVertex > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyVertex_get_ptr (vtkNew < vtkPolyVertex > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolygon > vtkPolygon_new () {return vtkNew < vtkPolygon > () ;} -extern "C" void vtkPolygon_destructor (vtkNew < vtkPolygon > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolygon_get_ptr (vtkNew < vtkPolygon > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyhedron > vtkPolyhedron_new () {return vtkNew < vtkPolyhedron > () ;} -extern "C" void vtkPolyhedron_destructor (vtkNew < vtkPolyhedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyhedron_get_ptr (vtkNew < vtkPolyhedron > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPyramid > vtkPyramid_new () {return vtkNew < vtkPyramid > () ;} -extern "C" void vtkPyramid_destructor (vtkNew < vtkPyramid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPyramid_get_ptr (vtkNew < vtkPyramid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuad > vtkQuad_new () {return vtkNew < vtkQuad > () ;} -extern "C" void vtkQuad_destructor (vtkNew < vtkQuad > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuad_get_ptr (vtkNew < vtkQuad > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticEdge > vtkQuadraticEdge_new () {return vtkNew < vtkQuadraticEdge > () ;} -extern "C" void vtkQuadraticEdge_destructor (vtkNew < vtkQuadraticEdge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticEdge_get_ptr (vtkNew < vtkQuadraticEdge > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticHexahedron > vtkQuadraticHexahedron_new () {return vtkNew < vtkQuadraticHexahedron > () ;} -extern "C" void vtkQuadraticHexahedron_destructor (vtkNew < vtkQuadraticHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticHexahedron_get_ptr (vtkNew < vtkQuadraticHexahedron > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticLinearQuad > vtkQuadraticLinearQuad_new () {return vtkNew < vtkQuadraticLinearQuad > () ;} -extern "C" void vtkQuadraticLinearQuad_destructor (vtkNew < vtkQuadraticLinearQuad > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticLinearQuad_get_ptr (vtkNew < vtkQuadraticLinearQuad > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticLinearWedge > vtkQuadraticLinearWedge_new () {return vtkNew < vtkQuadraticLinearWedge > () ;} -extern "C" void vtkQuadraticLinearWedge_destructor (vtkNew < vtkQuadraticLinearWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticLinearWedge_get_ptr (vtkNew < vtkQuadraticLinearWedge > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticPolygon > vtkQuadraticPolygon_new () {return vtkNew < vtkQuadraticPolygon > () ;} -extern "C" void vtkQuadraticPolygon_destructor (vtkNew < vtkQuadraticPolygon > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticPolygon_get_ptr (vtkNew < vtkQuadraticPolygon > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticPyramid > vtkQuadraticPyramid_new () {return vtkNew < vtkQuadraticPyramid > () ;} -extern "C" void vtkQuadraticPyramid_destructor (vtkNew < vtkQuadraticPyramid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticPyramid_get_ptr (vtkNew < vtkQuadraticPyramid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticQuad > vtkQuadraticQuad_new () {return vtkNew < vtkQuadraticQuad > () ;} -extern "C" void vtkQuadraticQuad_destructor (vtkNew < vtkQuadraticQuad > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticQuad_get_ptr (vtkNew < vtkQuadraticQuad > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticTetra > vtkQuadraticTetra_new () {return vtkNew < vtkQuadraticTetra > () ;} -extern "C" void vtkQuadraticTetra_destructor (vtkNew < vtkQuadraticTetra > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticTetra_get_ptr (vtkNew < vtkQuadraticTetra > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticTriangle > vtkQuadraticTriangle_new () {return vtkNew < vtkQuadraticTriangle > () ;} -extern "C" void vtkQuadraticTriangle_destructor (vtkNew < vtkQuadraticTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticTriangle_get_ptr (vtkNew < vtkQuadraticTriangle > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadraticWedge > vtkQuadraticWedge_new () {return vtkNew < vtkQuadraticWedge > () ;} -extern "C" void vtkQuadraticWedge_destructor (vtkNew < vtkQuadraticWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadraticWedge_get_ptr (vtkNew < vtkQuadraticWedge > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadratureSchemeDefinition > vtkQuadratureSchemeDefinition_new () {return vtkNew < vtkQuadratureSchemeDefinition > () ;} -extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkNew < vtkQuadratureSchemeDefinition > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadratureSchemeDefinition_get_ptr (vtkNew < vtkQuadratureSchemeDefinition > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuadric > vtkQuadric_new () {return vtkNew < vtkQuadric > () ;} -extern "C" void vtkQuadric_destructor (vtkNew < vtkQuadric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuadric_get_ptr (vtkNew < vtkQuadric > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkRectilinearGrid > vtkRectilinearGrid_new () {return vtkNew < vtkRectilinearGrid > () ;} -extern "C" void vtkRectilinearGrid_destructor (vtkNew < vtkRectilinearGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRectilinearGrid_get_ptr (vtkNew < vtkRectilinearGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkReebGraph > vtkReebGraph_new () {return vtkNew < vtkReebGraph > () ;} -extern "C" void vtkReebGraph_destructor (vtkNew < vtkReebGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkReebGraph_get_ptr (vtkNew < vtkReebGraph > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkReebGraphSimplificationMetric > vtkReebGraphSimplificationMetric_new () {return vtkNew < vtkReebGraphSimplificationMetric > () ;} -extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkNew < vtkReebGraphSimplificationMetric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkReebGraphSimplificationMetric_get_ptr (vtkNew < vtkReebGraphSimplificationMetric > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSelection > vtkSelection_new () {return vtkNew < vtkSelection > () ;} -extern "C" void vtkSelection_destructor (vtkNew < vtkSelection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSelection_get_ptr (vtkNew < vtkSelection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSelectionNode > vtkSelectionNode_new () {return vtkNew < vtkSelectionNode > () ;} -extern "C" void vtkSelectionNode_destructor (vtkNew < vtkSelectionNode > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSelectionNode_get_ptr (vtkNew < vtkSelectionNode > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSimpleCellTessellator > vtkSimpleCellTessellator_new () {return vtkNew < vtkSimpleCellTessellator > () ;} -extern "C" void vtkSimpleCellTessellator_destructor (vtkNew < vtkSimpleCellTessellator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSimpleCellTessellator_get_ptr (vtkNew < vtkSimpleCellTessellator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSmoothErrorMetric > vtkSmoothErrorMetric_new () {return vtkNew < vtkSmoothErrorMetric > () ;} -extern "C" void vtkSmoothErrorMetric_destructor (vtkNew < vtkSmoothErrorMetric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSmoothErrorMetric_get_ptr (vtkNew < vtkSmoothErrorMetric > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSortFieldData > vtkSortFieldData_new () {return vtkNew < vtkSortFieldData > () ;} -extern "C" void vtkSortFieldData_destructor (vtkNew < vtkSortFieldData > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSortFieldData_get_ptr (vtkNew < vtkSortFieldData > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSphere > vtkSphere_new () {return vtkNew < vtkSphere > () ;} -extern "C" void vtkSphere_destructor (vtkNew < vtkSphere > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSphere_get_ptr (vtkNew < vtkSphere > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSpheres > vtkSpheres_new () {return vtkNew < vtkSpheres > () ;} -extern "C" void vtkSpheres_destructor (vtkNew < vtkSpheres > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSpheres_get_ptr (vtkNew < vtkSpheres > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSphericalPointIterator > vtkSphericalPointIterator_new () {return vtkNew < vtkSphericalPointIterator > () ;} -extern "C" void vtkSphericalPointIterator_destructor (vtkNew < vtkSphericalPointIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSphericalPointIterator_get_ptr (vtkNew < vtkSphericalPointIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStaticCellLinks > vtkStaticCellLinks_new () {return vtkNew < vtkStaticCellLinks > () ;} -extern "C" void vtkStaticCellLinks_destructor (vtkNew < vtkStaticCellLinks > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStaticCellLinks_get_ptr (vtkNew < vtkStaticCellLinks > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStaticCellLocator > vtkStaticCellLocator_new () {return vtkNew < vtkStaticCellLocator > () ;} -extern "C" void vtkStaticCellLocator_destructor (vtkNew < vtkStaticCellLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStaticCellLocator_get_ptr (vtkNew < vtkStaticCellLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStaticPointLocator > vtkStaticPointLocator_new () {return vtkNew < vtkStaticPointLocator > () ;} -extern "C" void vtkStaticPointLocator_destructor (vtkNew < vtkStaticPointLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStaticPointLocator_get_ptr (vtkNew < vtkStaticPointLocator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStaticPointLocator2D > vtkStaticPointLocator2D_new () {return vtkNew < vtkStaticPointLocator2D > () ;} -extern "C" void vtkStaticPointLocator2D_destructor (vtkNew < vtkStaticPointLocator2D > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStaticPointLocator2D_get_ptr (vtkNew < vtkStaticPointLocator2D > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStructuredExtent > vtkStructuredExtent_new () {return vtkNew < vtkStructuredExtent > () ;} -extern "C" void vtkStructuredExtent_destructor (vtkNew < vtkStructuredExtent > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredExtent_get_ptr (vtkNew < vtkStructuredExtent > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStructuredGrid > vtkStructuredGrid_new () {return vtkNew < vtkStructuredGrid > () ;} -extern "C" void vtkStructuredGrid_destructor (vtkNew < vtkStructuredGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredGrid_get_ptr (vtkNew < vtkStructuredGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStructuredPoints > vtkStructuredPoints_new () {return vtkNew < vtkStructuredPoints > () ;} -extern "C" void vtkStructuredPoints_destructor (vtkNew < vtkStructuredPoints > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredPoints_get_ptr (vtkNew < vtkStructuredPoints > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStructuredPointsCollection > vtkStructuredPointsCollection_new () {return vtkNew < vtkStructuredPointsCollection > () ;} -extern "C" void vtkStructuredPointsCollection_destructor (vtkNew < vtkStructuredPointsCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredPointsCollection_get_ptr (vtkNew < vtkStructuredPointsCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSuperquadric > vtkSuperquadric_new () {return vtkNew < vtkSuperquadric > () ;} -extern "C" void vtkSuperquadric_destructor (vtkNew < vtkSuperquadric > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSuperquadric_get_ptr (vtkNew < vtkSuperquadric > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTable > vtkTable_new () {return vtkNew < vtkTable > () ;} -extern "C" void vtkTable_destructor (vtkNew < vtkTable > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTable_get_ptr (vtkNew < vtkTable > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTetra > vtkTetra_new () {return vtkNew < vtkTetra > () ;} -extern "C" void vtkTetra_destructor (vtkNew < vtkTetra > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTetra_get_ptr (vtkNew < vtkTetra > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTree > vtkTree_new () {return vtkNew < vtkTree > () ;} -extern "C" void vtkTree_destructor (vtkNew < vtkTree > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTree_get_ptr (vtkNew < vtkTree > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTreeBFSIterator > vtkTreeBFSIterator_new () {return vtkNew < vtkTreeBFSIterator > () ;} -extern "C" void vtkTreeBFSIterator_destructor (vtkNew < vtkTreeBFSIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTreeBFSIterator_get_ptr (vtkNew < vtkTreeBFSIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTreeDFSIterator > vtkTreeDFSIterator_new () {return vtkNew < vtkTreeDFSIterator > () ;} -extern "C" void vtkTreeDFSIterator_destructor (vtkNew < vtkTreeDFSIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTreeDFSIterator_get_ptr (vtkNew < vtkTreeDFSIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTriQuadraticHexahedron > vtkTriQuadraticHexahedron_new () {return vtkNew < vtkTriQuadraticHexahedron > () ;} -extern "C" void vtkTriQuadraticHexahedron_destructor (vtkNew < vtkTriQuadraticHexahedron > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTriQuadraticHexahedron_get_ptr (vtkNew < vtkTriQuadraticHexahedron > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTriQuadraticPyramid > vtkTriQuadraticPyramid_new () {return vtkNew < vtkTriQuadraticPyramid > () ;} -extern "C" void vtkTriQuadraticPyramid_destructor (vtkNew < vtkTriQuadraticPyramid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTriQuadraticPyramid_get_ptr (vtkNew < vtkTriQuadraticPyramid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTriangle > vtkTriangle_new () {return vtkNew < vtkTriangle > () ;} -extern "C" void vtkTriangle_destructor (vtkNew < vtkTriangle > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTriangle_get_ptr (vtkNew < vtkTriangle > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTriangleStrip > vtkTriangleStrip_new () {return vtkNew < vtkTriangleStrip > () ;} -extern "C" void vtkTriangleStrip_destructor (vtkNew < vtkTriangleStrip > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTriangleStrip_get_ptr (vtkNew < vtkTriangleStrip > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUndirectedGraph > vtkUndirectedGraph_new () {return vtkNew < vtkUndirectedGraph > () ;} -extern "C" void vtkUndirectedGraph_destructor (vtkNew < vtkUndirectedGraph > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUndirectedGraph_get_ptr (vtkNew < vtkUndirectedGraph > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUniformGrid > vtkUniformGrid_new () {return vtkNew < vtkUniformGrid > () ;} -extern "C" void vtkUniformGrid_destructor (vtkNew < vtkUniformGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGrid_get_ptr (vtkNew < vtkUniformGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUniformGridAMR > vtkUniformGridAMR_new () {return vtkNew < vtkUniformGridAMR > () ;} -extern "C" void vtkUniformGridAMR_destructor (vtkNew < vtkUniformGridAMR > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGridAMR_get_ptr (vtkNew < vtkUniformGridAMR > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUniformGridAMRDataIterator > vtkUniformGridAMRDataIterator_new () {return vtkNew < vtkUniformGridAMRDataIterator > () ;} -extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkNew < vtkUniformGridAMRDataIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGridAMRDataIterator_get_ptr (vtkNew < vtkUniformGridAMRDataIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUniformHyperTreeGrid > vtkUniformHyperTreeGrid_new () {return vtkNew < vtkUniformHyperTreeGrid > () ;} -extern "C" void vtkUniformHyperTreeGrid_destructor (vtkNew < vtkUniformHyperTreeGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformHyperTreeGrid_get_ptr (vtkNew < vtkUniformHyperTreeGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnstructuredGrid > vtkUnstructuredGrid_new () {return vtkNew < vtkUnstructuredGrid > () ;} -extern "C" void vtkUnstructuredGrid_destructor (vtkNew < vtkUnstructuredGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnstructuredGrid_get_ptr (vtkNew < vtkUnstructuredGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnstructuredGridCellIterator > vtkUnstructuredGridCellIterator_new () {return vtkNew < vtkUnstructuredGridCellIterator > () ;} -extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkNew < vtkUnstructuredGridCellIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnstructuredGridCellIterator_get_ptr (vtkNew < vtkUnstructuredGridCellIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkVertex > vtkVertex_new () {return vtkNew < vtkVertex > () ;} -extern "C" void vtkVertex_destructor (vtkNew < vtkVertex > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVertex_get_ptr (vtkNew < vtkVertex > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkVertexListIterator > vtkVertexListIterator_new () {return vtkNew < vtkVertexListIterator > () ;} -extern "C" void vtkVertexListIterator_destructor (vtkNew < vtkVertexListIterator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVertexListIterator_get_ptr (vtkNew < vtkVertexListIterator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkVoxel > vtkVoxel_new () {return vtkNew < vtkVoxel > () ;} -extern "C" void vtkVoxel_destructor (vtkNew < vtkVoxel > sself) {sself . Reset () ; return ;} -extern "C" void * vtkVoxel_get_ptr (vtkNew < vtkVoxel > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkWedge > vtkWedge_new () {return vtkNew < vtkWedge > () ;} -extern "C" void vtkWedge_destructor (vtkNew < vtkWedge > sself) {sself . Reset () ; return ;} -extern "C" void * vtkWedge_get_ptr (vtkNew < vtkWedge > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkXMLDataElement > vtkXMLDataElement_new () {return vtkNew < vtkXMLDataElement > () ;} -extern "C" void vtkXMLDataElement_destructor (vtkNew < vtkXMLDataElement > sself) {sself . Reset () ; return ;} -extern "C" void * vtkXMLDataElement_get_ptr (vtkNew < vtkXMLDataElement > sself) {return sself . GetPointer () ;} +extern "C" vtkAMRDataInternals * vtkAMRDataInternals_new () {return vtkAMRDataInternals :: New () ;} +extern "C" void vtkAMRDataInternals_destructor (vtkAMRDataInternals * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_amr_data_internals_initialize(vtkAMRDataInternals* sself) { sself->Initialize(); } +extern "C" bool vtk_amr_data_internals_empty(vtkAMRDataInternals* sself) { return sself->Empty(); } +extern "C" unsigned int vtk_amr_data_internals_get_number_of_blocks(vtkAMRDataInternals* sself) { return sself->GetNumberOfBlocks(); } +extern "C" vtkAdjacentVertexIterator * vtkAdjacentVertexIterator_new () {return vtkAdjacentVertexIterator :: New () ;} +extern "C" void vtkAdjacentVertexIterator_destructor (vtkAdjacentVertexIterator * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_adjacent_vertex_iterator_get_vertex(vtkAdjacentVertexIterator* sself) { return sself->GetVertex(); } +extern "C" long long vtk_adjacent_vertex_iterator_next(vtkAdjacentVertexIterator* sself) { return sself->Next(); } +extern "C" bool vtk_adjacent_vertex_iterator_has_next(vtkAdjacentVertexIterator* sself) { return sself->HasNext(); } +extern "C" vtkAnimationScene * vtkAnimationScene_new () {return vtkAnimationScene :: New () ;} +extern "C" void vtkAnimationScene_destructor (vtkAnimationScene * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_animation_scene_set_play_mode(vtkAnimationScene* sself, int _arg) { sself->SetPlayMode(_arg); } +extern "C" void vtk_animation_scene_set_mode_to_sequence(vtkAnimationScene* sself) { sself->SetModeToSequence(); } +extern "C" void vtk_animation_scene_set_mode_to_real_time(vtkAnimationScene* sself) { sself->SetModeToRealTime(); } +extern "C" int vtk_animation_scene_get_play_mode(vtkAnimationScene* sself) { return sself->GetPlayMode(); } +extern "C" void vtk_animation_scene_set_frame_rate(vtkAnimationScene* sself, double _arg) { sself->SetFrameRate(_arg); } +extern "C" double vtk_animation_scene_get_frame_rate(vtkAnimationScene* sself) { return sself->GetFrameRate(); } +extern "C" void vtk_animation_scene_remove_all_cues(vtkAnimationScene* sself) { sself->RemoveAllCues(); } +extern "C" int vtk_animation_scene_get_number_of_cues(vtkAnimationScene* sself) { return sself->GetNumberOfCues(); } +extern "C" void vtk_animation_scene_play(vtkAnimationScene* sself) { sself->Play(); } +extern "C" void vtk_animation_scene_stop(vtkAnimationScene* sself) { sself->Stop(); } +extern "C" void vtk_animation_scene_set_loop(vtkAnimationScene* sself, int _arg) { sself->SetLoop(_arg); } +extern "C" int vtk_animation_scene_get_loop(vtkAnimationScene* sself) { return sself->GetLoop(); } +extern "C" void vtk_animation_scene_set_animation_time(vtkAnimationScene* sself, double time) { sself->SetAnimationTime(time); } +extern "C" void vtk_animation_scene_set_time_mode(vtkAnimationScene* sself, int mode) { sself->SetTimeMode(mode); } +extern "C" int vtk_animation_scene_is_in_play(vtkAnimationScene* sself) { return sself->IsInPlay(); } +extern "C" vtkAnnotation * vtkAnnotation_new () {return vtkAnnotation :: New () ;} +extern "C" void vtkAnnotation_destructor (vtkAnnotation * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_annotation_get_data_object_type(vtkAnnotation* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_annotation_initialize(vtkAnnotation* sself) { sself->Initialize(); } +extern "C" unsigned long vtk_annotation_get_m_time(vtkAnnotation* sself) { return sself->GetMTime(); } +extern "C" vtkAnnotationLayers * vtkAnnotationLayers_new () {return vtkAnnotationLayers :: New () ;} +extern "C" void vtkAnnotationLayers_destructor (vtkAnnotationLayers * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_annotation_layers_get_data_object_type(vtkAnnotationLayers* sself) { return sself->GetDataObjectType(); } +extern "C" unsigned int vtk_annotation_layers_get_number_of_annotations(vtkAnnotationLayers* sself) { return sself->GetNumberOfAnnotations(); } +extern "C" void vtk_annotation_layers_initialize(vtkAnnotationLayers* sself) { sself->Initialize(); } +extern "C" unsigned long vtk_annotation_layers_get_m_time(vtkAnnotationLayers* sself) { return sself->GetMTime(); } +extern "C" vtkArrayData * vtkArrayData_new () {return vtkArrayData :: New () ;} +extern "C" void vtkArrayData_destructor (vtkArrayData * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_array_data_clear_arrays(vtkArrayData* sself) { sself->ClearArrays(); } +extern "C" long long vtk_array_data_get_number_of_arrays(vtkArrayData* sself) { return sself->GetNumberOfArrays(); } +extern "C" int vtk_array_data_get_data_object_type(vtkArrayData* sself) { return sself->GetDataObjectType(); } +extern "C" vtkAttributesErrorMetric * vtkAttributesErrorMetric_new () {return vtkAttributesErrorMetric :: New () ;} +extern "C" void vtkAttributesErrorMetric_destructor (vtkAttributesErrorMetric * sself) {sself -> Delete () ; return ;} +extern "C" double vtk_attributes_error_metric_get_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself) { return sself->GetAbsoluteAttributeTolerance(); } +extern "C" void vtk_attributes_error_metric_set_absolute_attribute_tolerance(vtkAttributesErrorMetric* sself, double value) { sself->SetAbsoluteAttributeTolerance(value); } +extern "C" double vtk_attributes_error_metric_get_attribute_tolerance(vtkAttributesErrorMetric* sself) { return sself->GetAttributeTolerance(); } +extern "C" void vtk_attributes_error_metric_set_attribute_tolerance(vtkAttributesErrorMetric* sself, double value) { sself->SetAttributeTolerance(value); } +extern "C" vtkBSPCuts * vtkBSPCuts_new () {return vtkBSPCuts :: New () ;} +extern "C" void vtkBSPCuts_destructor (vtkBSPCuts * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bsp_cuts_get_data_object_type(vtkBSPCuts* sself) { return sself->GetDataObjectType(); } +extern "C" int vtk_bsp_cuts_get_number_of_cuts(vtkBSPCuts* sself) { return sself->GetNumberOfCuts(); } +extern "C" void vtk_bsp_cuts_print_tree(vtkBSPCuts* sself) { sself->PrintTree(); } +extern "C" void vtk_bsp_cuts_print_arrays(vtkBSPCuts* sself) { sself->PrintArrays(); } +extern "C" vtkBSPIntersections * vtkBSPIntersections_new () {return vtkBSPIntersections :: New () ;} +extern "C" void vtkBSPIntersections_destructor (vtkBSPIntersections * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bsp_intersections_get_number_of_regions(vtkBSPIntersections* sself) { return sself->GetNumberOfRegions(); } +extern "C" int vtk_bsp_intersections_intersects_sphere_2(vtkBSPIntersections* sself, int regionId, double x, double y, double z, double rSquared) { return sself->IntersectsSphere2(regionId, x, y, z, rSquared); } +extern "C" int vtk_bsp_intersections_get_compute_intersections_using_data_bounds(vtkBSPIntersections* sself) { return sself->GetComputeIntersectionsUsingDataBounds(); } +extern "C" void vtk_bsp_intersections_set_compute_intersections_using_data_bounds(vtkBSPIntersections* sself, int c) { sself->SetComputeIntersectionsUsingDataBounds(c); } +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_on(vtkBSPIntersections* sself) { sself->ComputeIntersectionsUsingDataBoundsOn(); } +extern "C" void vtk_bsp_intersections_compute_intersections_using_data_bounds_off(vtkBSPIntersections* sself) { sself->ComputeIntersectionsUsingDataBoundsOff(); } +extern "C" vtkBezierCurve * vtkBezierCurve_new () {return vtkBezierCurve :: New () ;} +extern "C" void vtkBezierCurve_destructor (vtkBezierCurve * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bezier_curve_get_cell_type(vtkBezierCurve* sself) { return sself->GetCellType(); } +extern "C" vtkBezierHexahedron * vtkBezierHexahedron_new () {return vtkBezierHexahedron :: New () ;} +extern "C" void vtkBezierHexahedron_destructor (vtkBezierHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bezier_hexahedron_get_cell_type(vtkBezierHexahedron* sself) { return sself->GetCellType(); } +extern "C" vtkBezierInterpolation * vtkBezierInterpolation_new () {return vtkBezierInterpolation :: New () ;} +extern "C" void vtkBezierInterpolation_destructor (vtkBezierInterpolation * sself) {sself -> Delete () ; return ;} +extern "C" vtkBezierQuadrilateral * vtkBezierQuadrilateral_new () {return vtkBezierQuadrilateral :: New () ;} +extern "C" void vtkBezierQuadrilateral_destructor (vtkBezierQuadrilateral * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bezier_quadrilateral_get_cell_type(vtkBezierQuadrilateral* sself) { return sself->GetCellType(); } +extern "C" vtkBezierTetra * vtkBezierTetra_new () {return vtkBezierTetra :: New () ;} +extern "C" void vtkBezierTetra_destructor (vtkBezierTetra * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bezier_tetra_get_cell_type(vtkBezierTetra* sself) { return sself->GetCellType(); } +extern "C" vtkBezierTriangle * vtkBezierTriangle_new () {return vtkBezierTriangle :: New () ;} +extern "C" void vtkBezierTriangle_destructor (vtkBezierTriangle * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bezier_triangle_get_cell_type(vtkBezierTriangle* sself) { return sself->GetCellType(); } +extern "C" vtkBezierWedge * vtkBezierWedge_new () {return vtkBezierWedge :: New () ;} +extern "C" void vtkBezierWedge_destructor (vtkBezierWedge * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bezier_wedge_get_cell_type(vtkBezierWedge* sself) { return sself->GetCellType(); } +extern "C" vtkBiQuadraticQuad * vtkBiQuadraticQuad_new () {return vtkBiQuadraticQuad :: New () ;} +extern "C" void vtkBiQuadraticQuad_destructor (vtkBiQuadraticQuad * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bi_quadratic_quad_get_cell_type(vtkBiQuadraticQuad* sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quad_get_cell_dimension(vtkBiQuadraticQuad* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quad_get_number_of_edges(vtkBiQuadraticQuad* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quad_get_number_of_faces(vtkBiQuadraticQuad* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkBiQuadraticQuadraticHexahedron * vtkBiQuadraticQuadraticHexahedron_new () {return vtkBiQuadraticQuadraticHexahedron :: New () ;} +extern "C" void vtkBiQuadraticQuadraticHexahedron_destructor (vtkBiQuadraticQuadraticHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(vtkBiQuadraticQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkBiQuadraticQuadraticWedge * vtkBiQuadraticQuadraticWedge_new () {return vtkBiQuadraticQuadraticWedge :: New () ;} +extern "C" void vtkBiQuadraticQuadraticWedge_destructor (vtkBiQuadraticQuadraticWedge * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_type(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(vtkBiQuadraticQuadraticWedge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkBiQuadraticTriangle * vtkBiQuadraticTriangle_new () {return vtkBiQuadraticTriangle :: New () ;} +extern "C" void vtkBiQuadraticTriangle_destructor (vtkBiQuadraticTriangle * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_bi_quadratic_triangle_get_cell_type(vtkBiQuadraticTriangle* sself) { return sself->GetCellType(); } +extern "C" int vtk_bi_quadratic_triangle_get_cell_dimension(vtkBiQuadraticTriangle* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_bi_quadratic_triangle_get_number_of_edges(vtkBiQuadraticTriangle* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_bi_quadratic_triangle_get_number_of_faces(vtkBiQuadraticTriangle* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkBox * vtkBox_new () {return vtkBox :: New () ;} +extern "C" void vtkBox_destructor (vtkBox * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_box_set_x_min(vtkBox* sself, double x, double y, double z) { sself->SetXMin(x, y, z); } +extern "C" void vtk_box_get_x_min(vtkBox* sself, double& x, double& y, double& z) { sself->GetXMin(x, y, z); } +extern "C" void vtk_box_set_x_max(vtkBox* sself, double x, double y, double z) { sself->SetXMax(x, y, z); } +extern "C" void vtk_box_get_x_max(vtkBox* sself, double& x, double& y, double& z) { sself->GetXMax(x, y, z); } +extern "C" void vtk_box_set_bounds(vtkBox* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_box_get_bounds(vtkBox* sself, double& xMin, double& xMax, double& yMin, double& yMax, double& zMin, double& zMax) { sself->GetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" vtkCellArray * vtkCellArray_new () {return vtkCellArray :: New () ;} +extern "C" void vtkCellArray_destructor (vtkCellArray * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_cell_array_allocate(vtkCellArray* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" bool vtk_cell_array_allocate_estimate(vtkCellArray* sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_cell_array_allocate_exact(vtkCellArray* sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" bool vtk_cell_array_resize_exact(vtkCellArray* sself, long long numCells, long long connectivitySize) { return sself->ResizeExact(numCells, connectivitySize); } +extern "C" void vtk_cell_array_initialize(vtkCellArray* sself) { sself->Initialize(); } +extern "C" void vtk_cell_array_reset(vtkCellArray* sself) { sself->Reset(); } +extern "C" void vtk_cell_array_squeeze(vtkCellArray* sself) { sself->Squeeze(); } +extern "C" bool vtk_cell_array_is_valid(vtkCellArray* sself) { return sself->IsValid(); } +extern "C" long long vtk_cell_array_get_number_of_cells(vtkCellArray* sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_cell_array_get_number_of_offsets(vtkCellArray* sself) { return sself->GetNumberOfOffsets(); } +extern "C" long long vtk_cell_array_get_number_of_connectivity_ids(vtkCellArray* sself) { return sself->GetNumberOfConnectivityIds(); } +extern "C" bool vtk_cell_array_is_storage_64_bit(vtkCellArray* sself) { return sself->IsStorage64Bit(); } +extern "C" bool vtk_cell_array_is_storage_shareable(vtkCellArray* sself) { return sself->IsStorageShareable(); } +extern "C" void vtk_cell_array_use_32_bit_storage(vtkCellArray* sself) { sself->Use32BitStorage(); } +extern "C" void vtk_cell_array_use_64_bit_storage(vtkCellArray* sself) { sself->Use64BitStorage(); } +extern "C" void vtk_cell_array_use_default_storage(vtkCellArray* sself) { sself->UseDefaultStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_32_bit_storage(vtkCellArray* sself) { return sself->CanConvertTo32BitStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_64_bit_storage(vtkCellArray* sself) { return sself->CanConvertTo64BitStorage(); } +extern "C" bool vtk_cell_array_can_convert_to_default_storage(vtkCellArray* sself) { return sself->CanConvertToDefaultStorage(); } +extern "C" bool vtk_cell_array_convert_to_32_bit_storage(vtkCellArray* sself) { return sself->ConvertTo32BitStorage(); } +extern "C" bool vtk_cell_array_convert_to_64_bit_storage(vtkCellArray* sself) { return sself->ConvertTo64BitStorage(); } +extern "C" bool vtk_cell_array_convert_to_default_storage(vtkCellArray* sself) { return sself->ConvertToDefaultStorage(); } +extern "C" bool vtk_cell_array_convert_to_smallest_storage(vtkCellArray* sself) { return sself->ConvertToSmallestStorage(); } +extern "C" long long vtk_cell_array_is_homogeneous(vtkCellArray* sself) { return sself->IsHomogeneous(); } +extern "C" void vtk_cell_array_init_traversal(vtkCellArray* sself) { sself->InitTraversal(); } +extern "C" long long vtk_cell_array_get_cell_size(vtkCellArray* sself, const long long cellId) { return sself->GetCellSize(cellId); } +extern "C" void vtk_cell_array_insert_cell_point(vtkCellArray* sself, long long id) { sself->InsertCellPoint(id); } +extern "C" void vtk_cell_array_update_cell_count(vtkCellArray* sself, int npts) { sself->UpdateCellCount(npts); } +extern "C" long long vtk_cell_array_get_traversal_cell_id(vtkCellArray* sself) { return sself->GetTraversalCellId(); } +extern "C" void vtk_cell_array_set_traversal_cell_id(vtkCellArray* sself, long long cellId) { sself->SetTraversalCellId(cellId); } +extern "C" void vtk_cell_array_reverse_cell_at_id(vtkCellArray* sself, long long cellId) { sself->ReverseCellAtId(cellId); } +extern "C" int vtk_cell_array_get_max_cell_size(vtkCellArray* sself) { return sself->GetMaxCellSize(); } +extern "C" unsigned long vtk_cell_array_get_actual_memory_size(vtkCellArray* sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_cell_array_set_number_of_cells(vtkCellArray* sself, long long p0) { sself->SetNumberOfCells(p0); } +extern "C" long long vtk_cell_array_estimate_size(vtkCellArray* sself, long long numCells, int maxPtsPerCell) { return sself->EstimateSize(numCells, maxPtsPerCell); } +extern "C" long long vtk_cell_array_get_size(vtkCellArray* sself) { return sself->GetSize(); } +extern "C" long long vtk_cell_array_get_number_of_connectivity_entries(vtkCellArray* sself) { return sself->GetNumberOfConnectivityEntries(); } +extern "C" long long vtk_cell_array_get_insert_location(vtkCellArray* sself, int npts) { return sself->GetInsertLocation(npts); } +extern "C" long long vtk_cell_array_get_traversal_location(vtkCellArray* sself) { return sself->GetTraversalLocation(); } +extern "C" void vtk_cell_array_set_traversal_location(vtkCellArray* sself, long long loc) { sself->SetTraversalLocation(loc); } +extern "C" void vtk_cell_array_reverse_cell(vtkCellArray* sself, long long loc) { sself->ReverseCell(loc); } +extern "C" vtkCellArrayIterator * vtkCellArrayIterator_new () {return vtkCellArrayIterator :: New () ;} +extern "C" void vtkCellArrayIterator_destructor (vtkCellArrayIterator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cell_array_iterator_go_to_cell(vtkCellArrayIterator* sself, long long cellId) { sself->GoToCell(cellId); } +extern "C" void vtk_cell_array_iterator_go_to_first_cell(vtkCellArrayIterator* sself) { sself->GoToFirstCell(); } +extern "C" void vtk_cell_array_iterator_go_to_next_cell(vtkCellArrayIterator* sself) { sself->GoToNextCell(); } +extern "C" bool vtk_cell_array_iterator_is_done_with_traversal(vtkCellArrayIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_cell_array_iterator_get_current_cell_id(vtkCellArrayIterator* sself) { return sself->GetCurrentCellId(); } +extern "C" void vtk_cell_array_iterator_reverse_current_cell(vtkCellArrayIterator* sself) { sself->ReverseCurrentCell(); } +extern "C" vtkCellData * vtkCellData_new () {return vtkCellData :: New () ;} +extern "C" void vtkCellData_destructor (vtkCellData * sself) {sself -> Delete () ; return ;} +extern "C" vtkCellLinks * vtkCellLinks_new () {return vtkCellLinks :: New () ;} +extern "C" void vtkCellLinks_destructor (vtkCellLinks * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cell_links_allocate(vtkCellLinks* sself, long long numLinks, long long ext) { sself->Allocate(numLinks, ext); } +extern "C" void vtk_cell_links_initialize(vtkCellLinks* sself) { sself->Initialize(); } +extern "C" long long vtk_cell_links_get_ncells(vtkCellLinks* sself, long long ptId) { return sself->GetNcells(ptId); } +extern "C" long long vtk_cell_links_insert_next_point(vtkCellLinks* sself, int numLinks) { return sself->InsertNextPoint(numLinks); } +extern "C" void vtk_cell_links_insert_next_cell_reference(vtkCellLinks* sself, long long ptId, long long cellId) { sself->InsertNextCellReference(ptId, cellId); } +extern "C" void vtk_cell_links_delete_point(vtkCellLinks* sself, long long ptId) { sself->DeletePoint(ptId); } +extern "C" void vtk_cell_links_remove_cell_reference(vtkCellLinks* sself, long long cellId, long long ptId) { sself->RemoveCellReference(cellId, ptId); } +extern "C" void vtk_cell_links_add_cell_reference(vtkCellLinks* sself, long long cellId, long long ptId) { sself->AddCellReference(cellId, ptId); } +extern "C" void vtk_cell_links_resize_cell_list(vtkCellLinks* sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" void vtk_cell_links_squeeze(vtkCellLinks* sself) { sself->Squeeze(); } +extern "C" void vtk_cell_links_reset(vtkCellLinks* sself) { sself->Reset(); } +extern "C" unsigned long vtk_cell_links_get_actual_memory_size(vtkCellLinks* sself) { return sself->GetActualMemorySize(); } +extern "C" vtkCellLocator * vtkCellLocator_new () {return vtkCellLocator :: New () ;} +extern "C" void vtkCellLocator_destructor (vtkCellLocator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cell_locator_set_number_of_cells_per_bucket(vtkCellLocator* sself, int N) { sself->SetNumberOfCellsPerBucket(N); } +extern "C" int vtk_cell_locator_get_number_of_cells_per_bucket(vtkCellLocator* sself) { return sself->GetNumberOfCellsPerBucket(); } +extern "C" int vtk_cell_locator_get_number_of_buckets(vtkCellLocator* sself) { return sself->GetNumberOfBuckets(); } +extern "C" void vtk_cell_locator_free_search_structure(vtkCellLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_cell_locator_build_locator(vtkCellLocator* sself) { sself->BuildLocator(); } +extern "C" void vtk_cell_locator_build_locator_if_needed(vtkCellLocator* sself) { sself->BuildLocatorIfNeeded(); } +extern "C" void vtk_cell_locator_force_build_locator(vtkCellLocator* sself) { sself->ForceBuildLocator(); } +extern "C" void vtk_cell_locator_build_locator_internal(vtkCellLocator* sself) { sself->BuildLocatorInternal(); } +extern "C" vtkCellLocatorStrategy * vtkCellLocatorStrategy_new () {return vtkCellLocatorStrategy :: New () ;} +extern "C" void vtkCellLocatorStrategy_destructor (vtkCellLocatorStrategy * sself) {sself -> Delete () ; return ;} +extern "C" vtkCellTypes * vtkCellTypes_new () {return vtkCellTypes :: New () ;} +extern "C" void vtkCellTypes_destructor (vtkCellTypes * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_cell_types_allocate(vtkCellTypes* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_cell_types_insert_cell(vtkCellTypes* sself, long long id, unsigned char type, long long loc) { sself->InsertCell(id, type, loc); } +extern "C" long long vtk_cell_types_insert_next_cell(vtkCellTypes* sself, unsigned char type, long long loc) { return sself->InsertNextCell(type, loc); } +extern "C" long long vtk_cell_types_get_cell_location(vtkCellTypes* sself, long long cellId) { return sself->GetCellLocation(cellId); } +extern "C" void vtk_cell_types_delete_cell(vtkCellTypes* sself, long long cellId) { sself->DeleteCell(cellId); } +extern "C" long long vtk_cell_types_get_number_of_types(vtkCellTypes* sself) { return sself->GetNumberOfTypes(); } +extern "C" int vtk_cell_types_is_type(vtkCellTypes* sself, unsigned char type) { return sself->IsType(type); } +extern "C" long long vtk_cell_types_insert_next_type(vtkCellTypes* sself, unsigned char type) { return sself->InsertNextType(type); } +extern "C" unsigned char vtk_cell_types_get_cell_type(vtkCellTypes* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_cell_types_squeeze(vtkCellTypes* sself) { sself->Squeeze(); } +extern "C" void vtk_cell_types_reset(vtkCellTypes* sself) { sself->Reset(); } +extern "C" unsigned long vtk_cell_types_get_actual_memory_size(vtkCellTypes* sself) { return sself->GetActualMemorySize(); } +extern "C" const char* vtk_cell_types_get_class_name_from_type_id(vtkCellTypes* sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } +extern "C" int vtk_cell_types_get_type_id_from_class_name(vtkCellTypes* sself, const char* classname) { return sself->GetTypeIdFromClassName(classname); } +extern "C" int vtk_cell_types_is_linear(vtkCellTypes* sself, unsigned char type) { return sself->IsLinear(type); } +extern "C" vtkClosestNPointsStrategy * vtkClosestNPointsStrategy_new () {return vtkClosestNPointsStrategy :: New () ;} +extern "C" void vtkClosestNPointsStrategy_destructor (vtkClosestNPointsStrategy * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_closest_n_points_strategy_set_closest_n_points(vtkClosestNPointsStrategy* sself, int _arg) { sself->SetClosestNPoints(_arg); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_min_value(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPointsMinValue(); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points_max_value(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPointsMaxValue(); } +extern "C" int vtk_closest_n_points_strategy_get_closest_n_points(vtkClosestNPointsStrategy* sself) { return sself->GetClosestNPoints(); } +extern "C" vtkClosestPointStrategy * vtkClosestPointStrategy_new () {return vtkClosestPointStrategy :: New () ;} +extern "C" void vtkClosestPointStrategy_destructor (vtkClosestPointStrategy * sself) {sself -> Delete () ; return ;} +extern "C" vtkCone * vtkCone_new () {return vtkCone :: New () ;} +extern "C" void vtkCone_destructor (vtkCone * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cone_set_angle(vtkCone* sself, double _arg) { sself->SetAngle(_arg); } +extern "C" double vtk_cone_get_angle_min_value(vtkCone* sself) { return sself->GetAngleMinValue(); } +extern "C" double vtk_cone_get_angle_max_value(vtkCone* sself) { return sself->GetAngleMaxValue(); } +extern "C" double vtk_cone_get_angle(vtkCone* sself) { return sself->GetAngle(); } +extern "C" vtkConvexPointSet * vtkConvexPointSet_new () {return vtkConvexPointSet :: New () ;} +extern "C" void vtkConvexPointSet_destructor (vtkConvexPointSet * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_convex_point_set_has_fixed_topology(vtkConvexPointSet* sself) { return sself->HasFixedTopology(); } +extern "C" int vtk_convex_point_set_get_cell_type(vtkConvexPointSet* sself) { return sself->GetCellType(); } +extern "C" int vtk_convex_point_set_requires_initialization(vtkConvexPointSet* sself) { return sself->RequiresInitialization(); } +extern "C" int vtk_convex_point_set_get_number_of_edges(vtkConvexPointSet* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_convex_point_set_get_number_of_faces(vtkConvexPointSet* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_convex_point_set_is_primary_cell(vtkConvexPointSet* sself) { return sself->IsPrimaryCell(); } +extern "C" vtkCubicLine * vtkCubicLine_new () {return vtkCubicLine :: New () ;} +extern "C" void vtkCubicLine_destructor (vtkCubicLine * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_cubic_line_get_cell_type(vtkCubicLine* sself) { return sself->GetCellType(); } +extern "C" int vtk_cubic_line_get_cell_dimension(vtkCubicLine* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_cubic_line_get_number_of_edges(vtkCubicLine* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_cubic_line_get_number_of_faces(vtkCubicLine* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkCylinder * vtkCylinder_new () {return vtkCylinder :: New () ;} +extern "C" void vtkCylinder_destructor (vtkCylinder * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cylinder_set_radius(vtkCylinder* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_cylinder_get_radius(vtkCylinder* sself) { return sself->GetRadius(); } +extern "C" void vtk_cylinder_set_center(vtkCylinder* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cylinder_set_axis(vtkCylinder* sself, double ax, double ay, double az) { sself->SetAxis(ax, ay, az); } +extern "C" vtkDataAssembly * vtkDataAssembly_new () {return vtkDataAssembly :: New () ;} +extern "C" void vtkDataAssembly_destructor (vtkDataAssembly * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_data_assembly_initialize(vtkDataAssembly* sself) { sself->Initialize(); } +extern "C" bool vtk_data_assembly_initialize_from_xml(vtkDataAssembly* sself, const char* xmlcontents) { return sself->InitializeFromXML(xmlcontents); } +extern "C" int vtk_data_assembly_get_root_node(vtkDataAssembly* sself) { return sself->GetRootNode(); } +extern "C" void vtk_data_assembly_set_root_node_name(vtkDataAssembly* sself, const char* name) { sself->SetRootNodeName(name); } +extern "C" const char* vtk_data_assembly_get_root_node_name(vtkDataAssembly* sself) { return sself->GetRootNodeName(); } +extern "C" int vtk_data_assembly_add_node(vtkDataAssembly* sself, const char* name, int parent) { return sself->AddNode(name, parent); } +extern "C" bool vtk_data_assembly_remove_node(vtkDataAssembly* sself, int id) { return sself->RemoveNode(id); } +extern "C" void vtk_data_assembly_set_node_name(vtkDataAssembly* sself, int id, const char* name) { sself->SetNodeName(id, name); } +extern "C" const char* vtk_data_assembly_get_node_name(vtkDataAssembly* sself, int id) { return sself->GetNodeName(id); } +extern "C" int vtk_data_assembly_get_first_node_by_path(vtkDataAssembly* sself, const char* path) { return sself->GetFirstNodeByPath(path); } +extern "C" bool vtk_data_assembly_add_data_set_index(vtkDataAssembly* sself, int id, unsigned int dataset_index) { return sself->AddDataSetIndex(id, dataset_index); } +extern "C" bool vtk_data_assembly_add_data_set_index_range(vtkDataAssembly* sself, int id, unsigned int index_start, int count) { return sself->AddDataSetIndexRange(id, index_start, count); } +extern "C" bool vtk_data_assembly_remove_data_set_index(vtkDataAssembly* sself, int id, unsigned int dataset_index) { return sself->RemoveDataSetIndex(id, dataset_index); } +extern "C" bool vtk_data_assembly_remove_all_data_set_indices(vtkDataAssembly* sself, int id, bool traverse_subtree) { return sself->RemoveAllDataSetIndices(id, traverse_subtree); } +extern "C" int vtk_data_assembly_find_first_node_with_name(vtkDataAssembly* sself, const char* name, int traversal_order) { return sself->FindFirstNodeWithName(name, traversal_order); } +extern "C" int vtk_data_assembly_get_number_of_children(vtkDataAssembly* sself, int parent) { return sself->GetNumberOfChildren(parent); } +extern "C" int vtk_data_assembly_get_child(vtkDataAssembly* sself, int parent, int index) { return sself->GetChild(parent, index); } +extern "C" int vtk_data_assembly_get_child_index(vtkDataAssembly* sself, int parent, int child) { return sself->GetChildIndex(parent, child); } +extern "C" int vtk_data_assembly_get_parent(vtkDataAssembly* sself, int id) { return sself->GetParent(id); } +extern "C" bool vtk_data_assembly_has_attribute(vtkDataAssembly* sself, int id, const char* name) { return sself->HasAttribute(id, name); } +extern "C" void vtk_data_assembly_set_attribute(vtkDataAssembly* sself, int id, const char* name, const char* value) { sself->SetAttribute(id, name, value); } +extern "C" bool vtk_data_assembly_get_attribute(vtkDataAssembly* sself, int id, const char* name, const char* value) { return sself->GetAttribute(id, name, value); } +extern "C" const char* vtk_data_assembly_get_attribute_or_default(vtkDataAssembly* sself, int id, const char* name, const char* default_value) { return sself->GetAttributeOrDefault(id, name, default_value); } +extern "C" bool vtk_data_assembly_is_node_name_valid(vtkDataAssembly* sself, const char* name) { return sself->IsNodeNameValid(name); } +extern "C" bool vtk_data_assembly_is_node_name_reserved(vtkDataAssembly* sself, const char* name) { return sself->IsNodeNameReserved(name); } +extern "C" vtkDataAssemblyUtilities * vtkDataAssemblyUtilities_new () {return vtkDataAssemblyUtilities :: New () ;} +extern "C" void vtkDataAssemblyUtilities_destructor (vtkDataAssemblyUtilities * sself) {sself -> Delete () ; return ;} +extern "C" const char* vtk_data_assembly_utilities_hierarchy_name(vtkDataAssemblyUtilities* sself) { return sself->HierarchyName(); } +extern "C" vtkDataObject * vtkDataObject_new () {return vtkDataObject :: New () ;} +extern "C" void vtkDataObject_destructor (vtkDataObject * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_data_object_get_m_time(vtkDataObject* sself) { return sself->GetMTime(); } +extern "C" void vtk_data_object_initialize(vtkDataObject* sself) { sself->Initialize(); } +extern "C" void vtk_data_object_release_data(vtkDataObject* sself) { sself->ReleaseData(); } +extern "C" int vtk_data_object_get_data_released(vtkDataObject* sself) { return sself->GetDataReleased(); } +extern "C" void vtk_data_object_set_global_release_data_flag(vtkDataObject* sself, int val) { sself->SetGlobalReleaseDataFlag(val); } +extern "C" void vtk_data_object_global_release_data_flag_on(vtkDataObject* sself) { sself->GlobalReleaseDataFlagOn(); } +extern "C" void vtk_data_object_global_release_data_flag_off(vtkDataObject* sself) { sself->GlobalReleaseDataFlagOff(); } +extern "C" int vtk_data_object_get_global_release_data_flag(vtkDataObject* sself) { return sself->GetGlobalReleaseDataFlag(); } +extern "C" int vtk_data_object_get_data_object_type(vtkDataObject* sself) { return sself->GetDataObjectType(); } +extern "C" unsigned long vtk_data_object_get_update_time(vtkDataObject* sself) { return sself->GetUpdateTime(); } +extern "C" unsigned long vtk_data_object_get_actual_memory_size(vtkDataObject* sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_data_object_data_has_been_generated(vtkDataObject* sself) { sself->DataHasBeenGenerated(); } +extern "C" void vtk_data_object_prepare_for_new_data(vtkDataObject* sself) { sself->PrepareForNewData(); } +extern "C" int vtk_data_object_get_extent_type(vtkDataObject* sself) { return sself->GetExtentType(); } +extern "C" long long vtk_data_object_get_number_of_elements(vtkDataObject* sself, int type) { return sself->GetNumberOfElements(type); } +extern "C" const char* vtk_data_object_get_association_type_as_string(vtkDataObject* sself, int associationType) { return sself->GetAssociationTypeAsString(associationType); } +extern "C" int vtk_data_object_get_association_type_from_string(vtkDataObject* sself, const char* associationName) { return sself->GetAssociationTypeFromString(associationName); } +extern "C" vtkDataObjectCollection * vtkDataObjectCollection_new () {return vtkDataObjectCollection :: New () ;} +extern "C" void vtkDataObjectCollection_destructor (vtkDataObjectCollection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_data_object_collection_get_number_of_items(vtkDataObjectCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkDataObjectTreeIterator * vtkDataObjectTreeIterator_new () {return vtkDataObjectTreeIterator :: New () ;} +extern "C" void vtkDataObjectTreeIterator_destructor (vtkDataObjectTreeIterator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_data_object_tree_iterator_go_to_first_item(vtkDataObjectTreeIterator* sself) { sself->GoToFirstItem(); } +extern "C" void vtk_data_object_tree_iterator_go_to_next_item(vtkDataObjectTreeIterator* sself) { sself->GoToNextItem(); } +extern "C" int vtk_data_object_tree_iterator_is_done_with_traversal(vtkDataObjectTreeIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" int vtk_data_object_tree_iterator_has_current_meta_data(vtkDataObjectTreeIterator* sself) { return sself->HasCurrentMetaData(); } +extern "C" unsigned int vtk_data_object_tree_iterator_get_current_flat_index(vtkDataObjectTreeIterator* sself) { return sself->GetCurrentFlatIndex(); } +extern "C" void vtk_data_object_tree_iterator_set_visit_only_leaves(vtkDataObjectTreeIterator* sself, int _arg) { sself->SetVisitOnlyLeaves(_arg); } +extern "C" int vtk_data_object_tree_iterator_get_visit_only_leaves(vtkDataObjectTreeIterator* sself) { return sself->GetVisitOnlyLeaves(); } +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_on(vtkDataObjectTreeIterator* sself) { sself->VisitOnlyLeavesOn(); } +extern "C" void vtk_data_object_tree_iterator_visit_only_leaves_off(vtkDataObjectTreeIterator* sself) { sself->VisitOnlyLeavesOff(); } +extern "C" void vtk_data_object_tree_iterator_set_traverse_sub_tree(vtkDataObjectTreeIterator* sself, int _arg) { sself->SetTraverseSubTree(_arg); } +extern "C" int vtk_data_object_tree_iterator_get_traverse_sub_tree(vtkDataObjectTreeIterator* sself) { return sself->GetTraverseSubTree(); } +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_on(vtkDataObjectTreeIterator* sself) { sself->TraverseSubTreeOn(); } +extern "C" void vtk_data_object_tree_iterator_traverse_sub_tree_off(vtkDataObjectTreeIterator* sself) { sself->TraverseSubTreeOff(); } +extern "C" vtkDataObjectTypes * vtkDataObjectTypes_new () {return vtkDataObjectTypes :: New () ;} +extern "C" void vtkDataObjectTypes_destructor (vtkDataObjectTypes * sself) {sself -> Delete () ; return ;} +extern "C" const char* vtk_data_object_types_get_class_name_from_type_id(vtkDataObjectTypes* sself, int typeId) { return sself->GetClassNameFromTypeId(typeId); } +extern "C" int vtk_data_object_types_get_type_id_from_class_name(vtkDataObjectTypes* sself, const char* classname) { return sself->GetTypeIdFromClassName(classname); } +extern "C" bool vtk_data_object_types_type_id_is_a(vtkDataObjectTypes* sself, int typeId, int targetTypeId) { return sself->TypeIdIsA(typeId, targetTypeId); } +extern "C" int vtk_data_object_types_get_common_base_type_id(vtkDataObjectTypes* sself, int typeA, int typeB) { return sself->GetCommonBaseTypeId(typeA, typeB); } +extern "C" vtkDataSetAttributes * vtkDataSetAttributes_new () {return vtkDataSetAttributes :: New () ;} +extern "C" void vtkDataSetAttributes_destructor (vtkDataSetAttributes * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_data_set_attributes_initialize(vtkDataSetAttributes* sself) { sself->Initialize(); } +extern "C" void vtk_data_set_attributes_update(vtkDataSetAttributes* sself) { sself->Update(); } +extern "C" const char* vtk_data_set_attributes_ghost_array_name(vtkDataSetAttributes* sself) { return sself->GhostArrayName(); } +extern "C" int vtk_data_set_attributes_set_active_scalars(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveScalars(name); } +extern "C" int vtk_data_set_attributes_set_active_vectors(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveVectors(name); } +extern "C" int vtk_data_set_attributes_set_active_normals(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveNormals(name); } +extern "C" int vtk_data_set_attributes_set_active_tangents(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveTangents(name); } +extern "C" int vtk_data_set_attributes_set_active_t_coords(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveTCoords(name); } +extern "C" int vtk_data_set_attributes_set_active_tensors(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveTensors(name); } +extern "C" int vtk_data_set_attributes_set_active_global_ids(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveGlobalIds(name); } +extern "C" int vtk_data_set_attributes_set_active_pedigree_ids(vtkDataSetAttributes* sself, const char* name) { return sself->SetActivePedigreeIds(name); } +extern "C" int vtk_data_set_attributes_set_active_rational_weights(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveRationalWeights(name); } +extern "C" int vtk_data_set_attributes_set_active_higher_order_degrees(vtkDataSetAttributes* sself, const char* name) { return sself->SetActiveHigherOrderDegrees(name); } +extern "C" int vtk_data_set_attributes_set_active_attribute(vtkDataSetAttributes* sself, const char* name, int attributeType) { return sself->SetActiveAttribute(name, attributeType); } +extern "C" int vtk_data_set_attributes_is_array_an_attribute(vtkDataSetAttributes* sself, int idx) { return sself->IsArrayAnAttribute(idx); } +extern "C" const char* vtk_data_set_attributes_get_attribute_type_as_string(vtkDataSetAttributes* sself, int attributeType) { return sself->GetAttributeTypeAsString(attributeType); } +extern "C" const char* vtk_data_set_attributes_get_long_attribute_type_as_string(vtkDataSetAttributes* sself, int attributeType) { return sself->GetLongAttributeTypeAsString(attributeType); } +extern "C" void vtk_data_set_attributes_set_copy_attribute(vtkDataSetAttributes* sself, int index, int value, int ctype) { sself->SetCopyAttribute(index, value, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_attribute(vtkDataSetAttributes* sself, int index, int ctype) { return sself->GetCopyAttribute(index, ctype); } +extern "C" void vtk_data_set_attributes_set_copy_scalars(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyScalars(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_scalars(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyScalars(ctype); } +extern "C" void vtk_data_set_attributes_copy_scalars_on(vtkDataSetAttributes* sself) { sself->CopyScalarsOn(); } +extern "C" void vtk_data_set_attributes_copy_scalars_off(vtkDataSetAttributes* sself) { sself->CopyScalarsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_vectors(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyVectors(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_vectors(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyVectors(ctype); } +extern "C" void vtk_data_set_attributes_copy_vectors_on(vtkDataSetAttributes* sself) { sself->CopyVectorsOn(); } +extern "C" void vtk_data_set_attributes_copy_vectors_off(vtkDataSetAttributes* sself) { sself->CopyVectorsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_normals(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyNormals(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_normals(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyNormals(ctype); } +extern "C" void vtk_data_set_attributes_copy_normals_on(vtkDataSetAttributes* sself) { sself->CopyNormalsOn(); } +extern "C" void vtk_data_set_attributes_copy_normals_off(vtkDataSetAttributes* sself) { sself->CopyNormalsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_tangents(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyTangents(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_tangents(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyTangents(ctype); } +extern "C" void vtk_data_set_attributes_copy_tangents_on(vtkDataSetAttributes* sself) { sself->CopyTangentsOn(); } +extern "C" void vtk_data_set_attributes_copy_tangents_off(vtkDataSetAttributes* sself) { sself->CopyTangentsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_t_coords(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyTCoords(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_t_coords(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyTCoords(ctype); } +extern "C" void vtk_data_set_attributes_copy_t_coords_on(vtkDataSetAttributes* sself) { sself->CopyTCoordsOn(); } +extern "C" void vtk_data_set_attributes_copy_t_coords_off(vtkDataSetAttributes* sself) { sself->CopyTCoordsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_tensors(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyTensors(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_tensors(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyTensors(ctype); } +extern "C" void vtk_data_set_attributes_copy_tensors_on(vtkDataSetAttributes* sself) { sself->CopyTensorsOn(); } +extern "C" void vtk_data_set_attributes_copy_tensors_off(vtkDataSetAttributes* sself) { sself->CopyTensorsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_global_ids(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyGlobalIds(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_global_ids(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyGlobalIds(ctype); } +extern "C" void vtk_data_set_attributes_copy_global_ids_on(vtkDataSetAttributes* sself) { sself->CopyGlobalIdsOn(); } +extern "C" void vtk_data_set_attributes_copy_global_ids_off(vtkDataSetAttributes* sself) { sself->CopyGlobalIdsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_pedigree_ids(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyPedigreeIds(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_pedigree_ids(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyPedigreeIds(ctype); } +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_on(vtkDataSetAttributes* sself) { sself->CopyPedigreeIdsOn(); } +extern "C" void vtk_data_set_attributes_copy_pedigree_ids_off(vtkDataSetAttributes* sself) { sself->CopyPedigreeIdsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_rational_weights(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyRationalWeights(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_rational_weights(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyRationalWeights(ctype); } +extern "C" void vtk_data_set_attributes_copy_rational_weights_on(vtkDataSetAttributes* sself) { sself->CopyRationalWeightsOn(); } +extern "C" void vtk_data_set_attributes_copy_rational_weights_off(vtkDataSetAttributes* sself) { sself->CopyRationalWeightsOff(); } +extern "C" void vtk_data_set_attributes_set_copy_higher_order_degrees(vtkDataSetAttributes* sself, int i, int ctype) { sself->SetCopyHigherOrderDegrees(i, ctype); } +extern "C" int vtk_data_set_attributes_get_copy_higher_order_degrees(vtkDataSetAttributes* sself, int ctype) { return sself->GetCopyHigherOrderDegrees(ctype); } +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_on(vtkDataSetAttributes* sself) { sself->CopyHigherOrderDegreesOn(); } +extern "C" void vtk_data_set_attributes_copy_higher_order_degrees_off(vtkDataSetAttributes* sself) { sself->CopyHigherOrderDegreesOff(); } +extern "C" void vtk_data_set_attributes_copy_all_on(vtkDataSetAttributes* sself, int ctype) { sself->CopyAllOn(ctype); } +extern "C" void vtk_data_set_attributes_copy_all_off(vtkDataSetAttributes* sself, int ctype) { sself->CopyAllOff(ctype); } +extern "C" vtkDataSetCellIterator * vtkDataSetCellIterator_new () {return vtkDataSetCellIterator :: New () ;} +extern "C" void vtkDataSetCellIterator_destructor (vtkDataSetCellIterator * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_data_set_cell_iterator_is_done_with_traversal(vtkDataSetCellIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_data_set_cell_iterator_get_cell_id(vtkDataSetCellIterator* sself) { return sself->GetCellId(); } +extern "C" vtkDataSetCollection * vtkDataSetCollection_new () {return vtkDataSetCollection :: New () ;} +extern "C" void vtkDataSetCollection_destructor (vtkDataSetCollection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_data_set_collection_get_number_of_items(vtkDataSetCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkDirectedAcyclicGraph * vtkDirectedAcyclicGraph_new () {return vtkDirectedAcyclicGraph :: New () ;} +extern "C" void vtkDirectedAcyclicGraph_destructor (vtkDirectedAcyclicGraph * sself) {sself -> Delete () ; return ;} +extern "C" vtkDirectedGraph * vtkDirectedGraph_new () {return vtkDirectedGraph :: New () ;} +extern "C" void vtkDirectedGraph_destructor (vtkDirectedGraph * sself) {sself -> Delete () ; return ;} +extern "C" vtkEdgeListIterator * vtkEdgeListIterator_new () {return vtkEdgeListIterator :: New () ;} +extern "C" void vtkEdgeListIterator_destructor (vtkEdgeListIterator * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_edge_list_iterator_has_next(vtkEdgeListIterator* sself) { return sself->HasNext(); } +extern "C" vtkEdgeTable * vtkEdgeTable_new () {return vtkEdgeTable :: New () ;} +extern "C" void vtkEdgeTable_destructor (vtkEdgeTable * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_edge_table_initialize(vtkEdgeTable* sself) { sself->Initialize(); } +extern "C" int vtk_edge_table_init_edge_insertion(vtkEdgeTable* sself, long long numPoints, int storeAttributes) { return sself->InitEdgeInsertion(numPoints, storeAttributes); } +extern "C" long long vtk_edge_table_insert_edge(vtkEdgeTable* sself, long long p1, long long p2) { return sself->InsertEdge(p1, p2); } +extern "C" long long vtk_edge_table_is_edge(vtkEdgeTable* sself, long long p1, long long p2) { return sself->IsEdge(p1, p2); } +extern "C" long long vtk_edge_table_get_number_of_edges(vtkEdgeTable* sself) { return sself->GetNumberOfEdges(); } +extern "C" void vtk_edge_table_init_traversal(vtkEdgeTable* sself) { sself->InitTraversal(); } +extern "C" long long vtk_edge_table_get_next_edge(vtkEdgeTable* sself, long long& p1, long long& p2) { return sself->GetNextEdge(p1, p2); } +extern "C" void vtk_edge_table_reset(vtkEdgeTable* sself) { sself->Reset(); } +extern "C" vtkEmptyCell * vtkEmptyCell_new () {return vtkEmptyCell :: New () ;} +extern "C" void vtkEmptyCell_destructor (vtkEmptyCell * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_empty_cell_get_cell_type(vtkEmptyCell* sself) { return sself->GetCellType(); } +extern "C" int vtk_empty_cell_get_cell_dimension(vtkEmptyCell* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_empty_cell_get_number_of_edges(vtkEmptyCell* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_empty_cell_get_number_of_faces(vtkEmptyCell* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkExplicitStructuredGrid * vtkExplicitStructuredGrid_new () {return vtkExplicitStructuredGrid :: New () ;} +extern "C" void vtkExplicitStructuredGrid_destructor (vtkExplicitStructuredGrid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_explicit_structured_grid_get_data_object_type(vtkExplicitStructuredGrid* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_explicit_structured_grid_initialize(vtkExplicitStructuredGrid* sself) { sself->Initialize(); } +extern "C" int vtk_explicit_structured_grid_get_cell_type(vtkExplicitStructuredGrid* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_explicit_structured_grid_get_data_dimension(vtkExplicitStructuredGrid* sself) { return sself->GetDataDimension(); } +extern "C" void vtk_explicit_structured_grid_set_dimensions(vtkExplicitStructuredGrid* sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" int vtk_explicit_structured_grid_get_extent_type(vtkExplicitStructuredGrid* sself) { return sself->GetExtentType(); } +extern "C" void vtk_explicit_structured_grid_set_extent(vtkExplicitStructuredGrid* sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->SetExtent(x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_explicit_structured_grid_build_links(vtkExplicitStructuredGrid* sself) { sself->BuildLinks(); } +extern "C" void vtk_explicit_structured_grid_compute_cell_structured_coords(vtkExplicitStructuredGrid* sself, long long cellId, int& i, int& j, int& k, bool adjustForExtent) { sself->ComputeCellStructuredCoords(cellId, i, j, k, adjustForExtent); } +extern "C" long long vtk_explicit_structured_grid_compute_cell_id(vtkExplicitStructuredGrid* sself, int i, int j, int k, bool adjustForExtent) { return sself->ComputeCellId(i, j, k, adjustForExtent); } +extern "C" void vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(vtkExplicitStructuredGrid* sself) { sself->ComputeFacesConnectivityFlagsArray(); } +extern "C" void vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name(vtkExplicitStructuredGrid* sself, const char* _arg) { sself->SetFacesConnectivityFlagsArrayName(_arg); } +extern "C" void vtk_explicit_structured_grid_blank_cell(vtkExplicitStructuredGrid* sself, long long cellId) { sself->BlankCell(cellId); } +extern "C" void vtk_explicit_structured_grid_un_blank_cell(vtkExplicitStructuredGrid* sself, long long cellId) { sself->UnBlankCell(cellId); } +extern "C" bool vtk_explicit_structured_grid_has_any_blank_cells(vtkExplicitStructuredGrid* sself) { return sself->HasAnyBlankCells(); } +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_visible(vtkExplicitStructuredGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" unsigned char vtk_explicit_structured_grid_is_cell_ghost(vtkExplicitStructuredGrid* sself, long long cellId) { return sself->IsCellGhost(cellId); } +extern "C" bool vtk_explicit_structured_grid_has_any_ghost_cells(vtkExplicitStructuredGrid* sself) { return sself->HasAnyGhostCells(); } +extern "C" unsigned long vtk_explicit_structured_grid_get_actual_memory_size(vtkExplicitStructuredGrid* sself) { return sself->GetActualMemorySize(); } +extern "C" void vtk_explicit_structured_grid_check_and_reorder_faces(vtkExplicitStructuredGrid* sself) { sself->CheckAndReorderFaces(); } +extern "C" vtkExtractStructuredGridHelper * vtkExtractStructuredGridHelper_new () {return vtkExtractStructuredGridHelper :: New () ;} +extern "C" void vtkExtractStructuredGridHelper_destructor (vtkExtractStructuredGridHelper * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_extract_structured_grid_helper_is_valid(vtkExtractStructuredGridHelper* sself) { return sself->IsValid(); } +extern "C" int vtk_extract_structured_grid_helper_get_size(vtkExtractStructuredGridHelper* sself, const int dim) { return sself->GetSize(dim); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx) { return sself->GetMappedIndex(dim, outIdx); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value(vtkExtractStructuredGridHelper* sself, int dim, int outExtVal) { return sself->GetMappedIndexFromExtentValue(dim, outExtVal); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value(vtkExtractStructuredGridHelper* sself, int dim, int outExtVal) { return sself->GetMappedExtentValue(dim, outExtVal); } +extern "C" int vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index(vtkExtractStructuredGridHelper* sself, int dim, int outIdx) { return sself->GetMappedExtentValueFromIndex(dim, outIdx); } +extern "C" vtkFieldData * vtkFieldData_new () {return vtkFieldData :: New () ;} +extern "C" void vtkFieldData_destructor (vtkFieldData * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_field_data_initialize(vtkFieldData* sself) { sself->Initialize(); } +extern "C" int vtk_field_data_allocate(vtkFieldData* sself, long long sz, long long ext) { return sself->Allocate(sz, ext); } +extern "C" void vtk_field_data_allocate_arrays(vtkFieldData* sself, int num) { sself->AllocateArrays(num); } +extern "C" int vtk_field_data_get_number_of_arrays(vtkFieldData* sself) { return sself->GetNumberOfArrays(); } +extern "C" void vtk_field_data_null_data(vtkFieldData* sself, long long id) { sself->NullData(id); } +extern "C" void vtk_field_data_remove_array(vtkFieldData* sself, const char* name) { sself->RemoveArray(name); } +extern "C" int vtk_field_data_has_array(vtkFieldData* sself, const char* name) { return sself->HasArray(name); } +extern "C" const char* vtk_field_data_get_array_name(vtkFieldData* sself, int i) { return sself->GetArrayName(i); } +extern "C" void vtk_field_data_copy_field_on(vtkFieldData* sself, const char* name) { sself->CopyFieldOn(name); } +extern "C" void vtk_field_data_copy_field_off(vtkFieldData* sself, const char* name) { sself->CopyFieldOff(name); } +extern "C" void vtk_field_data_copy_all_on(vtkFieldData* sself, int unused) { sself->CopyAllOn(unused); } +extern "C" void vtk_field_data_copy_all_off(vtkFieldData* sself, int unused) { sself->CopyAllOff(unused); } +extern "C" void vtk_field_data_squeeze(vtkFieldData* sself) { sself->Squeeze(); } +extern "C" void vtk_field_data_reset(vtkFieldData* sself) { sself->Reset(); } +extern "C" unsigned long vtk_field_data_get_actual_memory_size(vtkFieldData* sself) { return sself->GetActualMemorySize(); } +extern "C" unsigned long vtk_field_data_get_m_time(vtkFieldData* sself) { return sself->GetMTime(); } +extern "C" int vtk_field_data_get_array_containing_component(vtkFieldData* sself, int i, int& arrayComp) { return sself->GetArrayContainingComponent(i, arrayComp); } +extern "C" int vtk_field_data_get_number_of_components(vtkFieldData* sself) { return sself->GetNumberOfComponents(); } +extern "C" long long vtk_field_data_get_number_of_tuples(vtkFieldData* sself) { return sself->GetNumberOfTuples(); } +extern "C" void vtk_field_data_set_number_of_tuples(vtkFieldData* sself, const long long number) { sself->SetNumberOfTuples(number); } +extern "C" vtkGenericAttributeCollection * vtkGenericAttributeCollection_new () {return vtkGenericAttributeCollection :: New () ;} +extern "C" void vtkGenericAttributeCollection_destructor (vtkGenericAttributeCollection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfAttributes(); } +extern "C" int vtk_generic_attribute_collection_get_number_of_components(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfComponents(); } +extern "C" int vtk_generic_attribute_collection_get_number_of_point_centered_components(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfPointCenteredComponents(); } +extern "C" int vtk_generic_attribute_collection_get_max_number_of_components(vtkGenericAttributeCollection* sself) { return sself->GetMaxNumberOfComponents(); } +extern "C" unsigned long vtk_generic_attribute_collection_get_actual_memory_size(vtkGenericAttributeCollection* sself) { return sself->GetActualMemorySize(); } +extern "C" int vtk_generic_attribute_collection_is_empty(vtkGenericAttributeCollection* sself) { return sself->IsEmpty(); } +extern "C" int vtk_generic_attribute_collection_find_attribute(vtkGenericAttributeCollection* sself, const char* name) { return sself->FindAttribute(name); } +extern "C" int vtk_generic_attribute_collection_get_attribute_index(vtkGenericAttributeCollection* sself, int i) { return sself->GetAttributeIndex(i); } +extern "C" void vtk_generic_attribute_collection_remove_attribute(vtkGenericAttributeCollection* sself, int i) { sself->RemoveAttribute(i); } +extern "C" void vtk_generic_attribute_collection_reset(vtkGenericAttributeCollection* sself) { sself->Reset(); } +extern "C" unsigned long vtk_generic_attribute_collection_get_m_time(vtkGenericAttributeCollection* sself) { return sself->GetMTime(); } +extern "C" int vtk_generic_attribute_collection_get_active_attribute(vtkGenericAttributeCollection* sself) { return sself->GetActiveAttribute(); } +extern "C" int vtk_generic_attribute_collection_get_active_component(vtkGenericAttributeCollection* sself) { return sself->GetActiveComponent(); } +extern "C" void vtk_generic_attribute_collection_set_active_attribute(vtkGenericAttributeCollection* sself, int attribute, int component) { sself->SetActiveAttribute(attribute, component); } +extern "C" int vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate(vtkGenericAttributeCollection* sself) { return sself->GetNumberOfAttributesToInterpolate(); } +extern "C" void vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(vtkGenericAttributeCollection* sself) { sself->SetAttributesToInterpolateToAll(); } +extern "C" vtkGenericCell * vtkGenericCell_new () {return vtkGenericCell :: New () ;} +extern "C" void vtkGenericCell_destructor (vtkGenericCell * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_generic_cell_get_cell_type(vtkGenericCell* sself) { return sself->GetCellType(); } +extern "C" int vtk_generic_cell_get_cell_dimension(vtkGenericCell* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_generic_cell_get_number_of_edges(vtkGenericCell* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_generic_cell_get_number_of_faces(vtkGenericCell* sself) { return sself->GetNumberOfFaces(); } +extern "C" void vtk_generic_cell_set_cell_type(vtkGenericCell* sself, int cellType) { sself->SetCellType(cellType); } +extern "C" void vtk_generic_cell_set_cell_type_to_empty_cell(vtkGenericCell* sself) { sself->SetCellTypeToEmptyCell(); } +extern "C" void vtk_generic_cell_set_cell_type_to_vertex(vtkGenericCell* sself) { sself->SetCellTypeToVertex(); } +extern "C" void vtk_generic_cell_set_cell_type_to_poly_vertex(vtkGenericCell* sself) { sself->SetCellTypeToPolyVertex(); } +extern "C" void vtk_generic_cell_set_cell_type_to_line(vtkGenericCell* sself) { sself->SetCellTypeToLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_poly_line(vtkGenericCell* sself) { sself->SetCellTypeToPolyLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_triangle(vtkGenericCell* sself) { sself->SetCellTypeToTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_triangle_strip(vtkGenericCell* sself) { sself->SetCellTypeToTriangleStrip(); } +extern "C" void vtk_generic_cell_set_cell_type_to_polygon(vtkGenericCell* sself) { sself->SetCellTypeToPolygon(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pixel(vtkGenericCell* sself) { sself->SetCellTypeToPixel(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quad(vtkGenericCell* sself) { sself->SetCellTypeToQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tetra(vtkGenericCell* sself) { sself->SetCellTypeToTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_voxel(vtkGenericCell* sself) { sself->SetCellTypeToVoxel(); } +extern "C" void vtk_generic_cell_set_cell_type_to_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_wedge(vtkGenericCell* sself) { sself->SetCellTypeToWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pyramid(vtkGenericCell* sself) { sself->SetCellTypeToPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_pentagonal_prism(vtkGenericCell* sself) { sself->SetCellTypeToPentagonalPrism(); } +extern "C" void vtk_generic_cell_set_cell_type_to_hexagonal_prism(vtkGenericCell* sself) { sself->SetCellTypeToHexagonalPrism(); } +extern "C" void vtk_generic_cell_set_cell_type_to_polyhedron(vtkGenericCell* sself) { sself->SetCellTypeToPolyhedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_convex_point_set(vtkGenericCell* sself) { sself->SetCellTypeToConvexPointSet(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_edge(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticEdge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_cubic_line(vtkGenericCell* sself) { sself->SetCellTypeToCubicLine(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_triangle(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(vtkGenericCell* sself) { sself->SetCellTypeToBiQuadraticTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_quad(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_polygon(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticPolygon(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_tetra(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_wedge(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_pyramid(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticLinearQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(vtkGenericCell* sself) { sself->SetCellTypeToBiQuadraticQuad(); } +extern "C" void vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(vtkGenericCell* sself) { sself->SetCellTypeToQuadraticLinearWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(vtkGenericCell* sself) { sself->SetCellTypeToBiQuadraticQuadraticWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToTriQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(vtkGenericCell* sself) { sself->SetCellTypeToTriQuadraticPyramid(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToBiQuadraticQuadraticHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_triangle(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_tetra(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_curve(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeCurve(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeQuadrilateral(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_lagrange_wedge(vtkGenericCell* sself) { sself->SetCellTypeToLagrangeWedge(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_triangle(vtkGenericCell* sself) { sself->SetCellTypeToBezierTriangle(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_tetra(vtkGenericCell* sself) { sself->SetCellTypeToBezierTetra(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_curve(vtkGenericCell* sself) { sself->SetCellTypeToBezierCurve(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(vtkGenericCell* sself) { sself->SetCellTypeToBezierQuadrilateral(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_hexahedron(vtkGenericCell* sself) { sself->SetCellTypeToBezierHexahedron(); } +extern "C" void vtk_generic_cell_set_cell_type_to_bezier_wedge(vtkGenericCell* sself) { sself->SetCellTypeToBezierWedge(); } +extern "C" vtkGenericEdgeTable * vtkGenericEdgeTable_new () {return vtkGenericEdgeTable :: New () ;} +extern "C" void vtkGenericEdgeTable_destructor (vtkGenericEdgeTable * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_generic_edge_table_insert_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId, int ref, long long& ptId) { sself->InsertEdge(e1, e2, cellId, ref, ptId); } +extern "C" int vtk_generic_edge_table_remove_edge(vtkGenericEdgeTable* sself, long long e1, long long e2) { return sself->RemoveEdge(e1, e2); } +extern "C" int vtk_generic_edge_table_check_edge(vtkGenericEdgeTable* sself, long long e1, long long e2, long long& ptId) { return sself->CheckEdge(e1, e2, ptId); } +extern "C" int vtk_generic_edge_table_increment_edge_reference_count(vtkGenericEdgeTable* sself, long long e1, long long e2, long long cellId) { return sself->IncrementEdgeReferenceCount(e1, e2, cellId); } +extern "C" int vtk_generic_edge_table_check_edge_reference_count(vtkGenericEdgeTable* sself, long long e1, long long e2) { return sself->CheckEdgeReferenceCount(e1, e2); } +extern "C" void vtk_generic_edge_table_initialize(vtkGenericEdgeTable* sself, long long start) { sself->Initialize(start); } +extern "C" int vtk_generic_edge_table_get_number_of_components(vtkGenericEdgeTable* sself) { return sself->GetNumberOfComponents(); } +extern "C" void vtk_generic_edge_table_set_number_of_components(vtkGenericEdgeTable* sself, int count) { sself->SetNumberOfComponents(count); } +extern "C" int vtk_generic_edge_table_check_point(vtkGenericEdgeTable* sself, long long ptId) { return sself->CheckPoint(ptId); } +extern "C" void vtk_generic_edge_table_remove_point(vtkGenericEdgeTable* sself, long long ptId) { sself->RemovePoint(ptId); } +extern "C" void vtk_generic_edge_table_increment_point_reference_count(vtkGenericEdgeTable* sself, long long ptId) { sself->IncrementPointReferenceCount(ptId); } +extern "C" void vtk_generic_edge_table_dump_table(vtkGenericEdgeTable* sself) { sself->DumpTable(); } +extern "C" void vtk_generic_edge_table_load_factor(vtkGenericEdgeTable* sself) { sself->LoadFactor(); } +extern "C" vtkGenericInterpolatedVelocityField * vtkGenericInterpolatedVelocityField_new () {return vtkGenericInterpolatedVelocityField :: New () ;} +extern "C" void vtkGenericInterpolatedVelocityField_destructor (vtkGenericInterpolatedVelocityField * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_generic_interpolated_velocity_field_clear_last_cell(vtkGenericInterpolatedVelocityField* sself) { sself->ClearLastCell(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_caching(vtkGenericInterpolatedVelocityField* sself) { return sself->GetCaching(); } +extern "C" void vtk_generic_interpolated_velocity_field_set_caching(vtkGenericInterpolatedVelocityField* sself, int _arg) { sself->SetCaching(_arg); } +extern "C" void vtk_generic_interpolated_velocity_field_caching_on(vtkGenericInterpolatedVelocityField* sself) { sself->CachingOn(); } +extern "C" void vtk_generic_interpolated_velocity_field_caching_off(vtkGenericInterpolatedVelocityField* sself) { sself->CachingOff(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_hit(vtkGenericInterpolatedVelocityField* sself) { return sself->GetCacheHit(); } +extern "C" int vtk_generic_interpolated_velocity_field_get_cache_miss(vtkGenericInterpolatedVelocityField* sself) { return sself->GetCacheMiss(); } +extern "C" void vtk_generic_interpolated_velocity_field_select_vectors(vtkGenericInterpolatedVelocityField* sself, const char* fieldName) { sself->SelectVectors(fieldName); } +extern "C" vtkGeometricErrorMetric * vtkGeometricErrorMetric_new () {return vtkGeometricErrorMetric :: New () ;} +extern "C" void vtkGeometricErrorMetric_destructor (vtkGeometricErrorMetric * sself) {sself -> Delete () ; return ;} +extern "C" double vtk_geometric_error_metric_get_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself) { return sself->GetAbsoluteGeometricTolerance(); } +extern "C" void vtk_geometric_error_metric_set_absolute_geometric_tolerance(vtkGeometricErrorMetric* sself, double value) { sself->SetAbsoluteGeometricTolerance(value); } +extern "C" int vtk_geometric_error_metric_get_relative(vtkGeometricErrorMetric* sself) { return sself->GetRelative(); } +extern "C" vtkGraphEdge * vtkGraphEdge_new () {return vtkGraphEdge :: New () ;} +extern "C" void vtkGraphEdge_destructor (vtkGraphEdge * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_graph_edge_set_source(vtkGraphEdge* sself, long long _arg) { sself->SetSource(_arg); } +extern "C" long long vtk_graph_edge_get_source(vtkGraphEdge* sself) { return sself->GetSource(); } +extern "C" void vtk_graph_edge_set_target(vtkGraphEdge* sself, long long _arg) { sself->SetTarget(_arg); } +extern "C" long long vtk_graph_edge_get_target(vtkGraphEdge* sself) { return sself->GetTarget(); } +extern "C" void vtk_graph_edge_set_id(vtkGraphEdge* sself, long long _arg) { sself->SetId(_arg); } +extern "C" long long vtk_graph_edge_get_id(vtkGraphEdge* sself) { return sself->GetId(); } +extern "C" vtkGraphInternals * vtkGraphInternals_new () {return vtkGraphInternals :: New () ;} +extern "C" void vtkGraphInternals_destructor (vtkGraphInternals * sself) {sself -> Delete () ; return ;} +extern "C" vtkHexagonalPrism * vtkHexagonalPrism_new () {return vtkHexagonalPrism :: New () ;} +extern "C" void vtkHexagonalPrism_destructor (vtkHexagonalPrism * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_hexagonal_prism_get_cell_type(vtkHexagonalPrism* sself) { return sself->GetCellType(); } +extern "C" int vtk_hexagonal_prism_get_number_of_edges(vtkHexagonalPrism* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_hexagonal_prism_get_number_of_faces(vtkHexagonalPrism* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkHexahedron * vtkHexahedron_new () {return vtkHexahedron :: New () ;} +extern "C" void vtkHexahedron_destructor (vtkHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_hexahedron_get_cell_type(vtkHexahedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_hexahedron_get_number_of_edges(vtkHexahedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_hexahedron_get_number_of_faces(vtkHexahedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkHierarchicalBoxDataIterator * vtkHierarchicalBoxDataIterator_new () {return vtkHierarchicalBoxDataIterator :: New () ;} +extern "C" void vtkHierarchicalBoxDataIterator_destructor (vtkHierarchicalBoxDataIterator * sself) {sself -> Delete () ; return ;} +extern "C" vtkHierarchicalBoxDataSet * vtkHierarchicalBoxDataSet_new () {return vtkHierarchicalBoxDataSet :: New () ;} +extern "C" void vtkHierarchicalBoxDataSet_destructor (vtkHierarchicalBoxDataSet * sself) {sself -> Delete () ; return ;} +extern "C" vtkHyperTreeGrid * vtkHyperTreeGrid_new () {return vtkHyperTreeGrid :: New () ;} +extern "C" void vtkHyperTreeGrid_destructor (vtkHyperTreeGrid * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_hyper_tree_grid_set_mode_squeeze(vtkHyperTreeGrid* sself, const char* _arg) { sself->SetModeSqueeze(_arg); } +extern "C" void vtk_hyper_tree_grid_squeeze(vtkHyperTreeGrid* sself) { sself->Squeeze(); } +extern "C" int vtk_hyper_tree_grid_get_data_object_type(vtkHyperTreeGrid* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_hyper_tree_grid_set_dimensions(vtkHyperTreeGrid* sself, unsigned int i, unsigned int j, unsigned int k) { sself->SetDimensions(i, j, k); } +extern "C" void vtk_hyper_tree_grid_set_extent(vtkHyperTreeGrid* sself, int x1, int x2, int y1, int y2, int z1, int z2) { sself->SetExtent(x1, x2, y1, y2, z1, z2); } +extern "C" unsigned int vtk_hyper_tree_grid_get_dimension(vtkHyperTreeGrid* sself) { return sself->GetDimension(); } +extern "C" void vtk_hyper_tree_grid_get_1_d_axis(vtkHyperTreeGrid* sself, unsigned int& axis) { sself->Get1DAxis(axis); } +extern "C" void vtk_hyper_tree_grid_get_2_d_axes(vtkHyperTreeGrid* sself, unsigned int& axis1, unsigned int& axis2) { sself->Get2DAxes(axis1, axis2); } +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_children(vtkHyperTreeGrid* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_set_transposed_root_indexing(vtkHyperTreeGrid* sself, bool _arg) { sself->SetTransposedRootIndexing(_arg); } +extern "C" bool vtk_hyper_tree_grid_get_transposed_root_indexing(vtkHyperTreeGrid* sself) { return sself->GetTransposedRootIndexing(); } +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_kji(vtkHyperTreeGrid* sself) { sself->SetIndexingModeToKJI(); } +extern "C" void vtk_hyper_tree_grid_set_indexing_mode_to_ijk(vtkHyperTreeGrid* sself) { sself->SetIndexingModeToIJK(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_orientation(vtkHyperTreeGrid* sself) { return sself->GetOrientation(); } +extern "C" bool vtk_hyper_tree_grid_get_freeze_state(vtkHyperTreeGrid* sself) { return sself->GetFreezeState(); } +extern "C" void vtk_hyper_tree_grid_set_branch_factor(vtkHyperTreeGrid* sself, unsigned int p0) { sself->SetBranchFactor(p0); } +extern "C" unsigned int vtk_hyper_tree_grid_get_branch_factor(vtkHyperTreeGrid* sself) { return sself->GetBranchFactor(); } +extern "C" long long vtk_hyper_tree_grid_get_max_number_of_trees(vtkHyperTreeGrid* sself) { return sself->GetMaxNumberOfTrees(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_vertices(vtkHyperTreeGrid* sself) { return sself->GetNumberOfVertices(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_non_empty_trees(vtkHyperTreeGrid* sself) { return sself->GetNumberOfNonEmptyTrees(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_leaves(vtkHyperTreeGrid* sself) { return sself->GetNumberOfLeaves(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_number_of_levels(vtkHyperTreeGrid* sself, long long p0) { return sself->GetNumberOfLevels(p0); } +extern "C" void vtk_hyper_tree_grid_set_fixed_coordinates(vtkHyperTreeGrid* sself, unsigned int axis, double value) { sself->SetFixedCoordinates(axis, value); } +extern "C" bool vtk_hyper_tree_grid_has_mask(vtkHyperTreeGrid* sself) { return sself->HasMask(); } +extern "C" void vtk_hyper_tree_grid_set_has_interface(vtkHyperTreeGrid* sself, bool _arg) { sself->SetHasInterface(_arg); } +extern "C" bool vtk_hyper_tree_grid_get_has_interface(vtkHyperTreeGrid* sself) { return sself->GetHasInterface(); } +extern "C" void vtk_hyper_tree_grid_has_interface_on(vtkHyperTreeGrid* sself) { sself->HasInterfaceOn(); } +extern "C" void vtk_hyper_tree_grid_has_interface_off(vtkHyperTreeGrid* sself) { sself->HasInterfaceOff(); } +extern "C" void vtk_hyper_tree_grid_set_interface_normals_name(vtkHyperTreeGrid* sself, const char* _arg) { sself->SetInterfaceNormalsName(_arg); } +extern "C" void vtk_hyper_tree_grid_set_interface_intercepts_name(vtkHyperTreeGrid* sself, const char* _arg) { sself->SetInterfaceInterceptsName(_arg); } +extern "C" void vtk_hyper_tree_grid_set_depth_limiter(vtkHyperTreeGrid* sself, unsigned int _arg) { sself->SetDepthLimiter(_arg); } +extern "C" unsigned int vtk_hyper_tree_grid_get_depth_limiter(vtkHyperTreeGrid* sself) { return sself->GetDepthLimiter(); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_x(vtkHyperTreeGrid* sself, double value) { return sself->FindDichotomicX(value); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_y(vtkHyperTreeGrid* sself, double value) { return sself->FindDichotomicY(value); } +extern "C" unsigned int vtk_hyper_tree_grid_find_dichotomic_z(vtkHyperTreeGrid* sself, double value) { return sself->FindDichotomicZ(value); } +extern "C" void vtk_hyper_tree_grid_initialize(vtkHyperTreeGrid* sself) { sself->Initialize(); } +extern "C" int vtk_hyper_tree_grid_get_extent_type(vtkHyperTreeGrid* sself) { return sself->GetExtentType(); } +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size_bytes(vtkHyperTreeGrid* sself) { return sself->GetActualMemorySizeBytes(); } +extern "C" unsigned long vtk_hyper_tree_grid_get_actual_memory_size(vtkHyperTreeGrid* sself) { return sself->GetActualMemorySize(); } +extern "C" unsigned int vtk_hyper_tree_grid_get_child_mask(vtkHyperTreeGrid* sself, unsigned int p0) { return sself->GetChildMask(p0); } +extern "C" void vtk_hyper_tree_grid_get_index_from_level_zero_coordinates(vtkHyperTreeGrid* sself, long long& p0, unsigned int p1, unsigned int p2, unsigned int p3) { sself->GetIndexFromLevelZeroCoordinates(p0, p1, p2, p3); } +extern "C" long long vtk_hyper_tree_grid_get_shifted_level_zero_index(vtkHyperTreeGrid* sself, long long p0, unsigned int p1, unsigned int p2, unsigned int p3) { return sself->GetShiftedLevelZeroIndex(p0, p1, p2, p3); } +extern "C" void vtk_hyper_tree_grid_get_level_zero_coordinates_from_index(vtkHyperTreeGrid* sself, long long p0, unsigned int& p1, unsigned int& p2, unsigned int& p3) { sself->GetLevelZeroCoordinatesFromIndex(p0, p1, p2, p3); } +extern "C" long long vtk_hyper_tree_grid_get_global_node_index_max(vtkHyperTreeGrid* sself) { return sself->GetGlobalNodeIndexMax(); } +extern "C" void vtk_hyper_tree_grid_initialize_local_index_node(vtkHyperTreeGrid* sself) { sself->InitializeLocalIndexNode(); } +extern "C" bool vtk_hyper_tree_grid_has_any_ghost_cells(vtkHyperTreeGrid* sself) { return sself->HasAnyGhostCells(); } +extern "C" long long vtk_hyper_tree_grid_get_number_of_elements(vtkHyperTreeGrid* sself, int type) { return sself->GetNumberOfElements(type); } +extern "C" vtkHyperTreeGridNonOrientedCursor * vtkHyperTreeGridNonOrientedCursor_new () {return vtkHyperTreeGridNonOrientedCursor :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedCursor_destructor (vtkHyperTreeGridNonOrientedCursor * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_has_tree(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(vtkHyperTreeGridNonOrientedCursor* sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local(vtkHyperTreeGridNonOrientedCursor* sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_set_mask(vtkHyperTreeGridNonOrientedCursor* sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_masked(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(vtkHyperTreeGridNonOrientedCursor* sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_cursor_is_root(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_cursor_get_level(vtkHyperTreeGridNonOrientedCursor* sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_child(vtkHyperTreeGridNonOrientedCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_root(vtkHyperTreeGridNonOrientedCursor* sself) { sself->ToRoot(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_cursor_to_parent(vtkHyperTreeGridNonOrientedCursor* sself) { sself->ToParent(); } +extern "C" vtkHyperTreeGridNonOrientedGeometryCursor * vtkHyperTreeGridNonOrientedGeometryCursor_new () {return vtkHyperTreeGridNonOrientedGeometryCursor :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedGeometryCursor_destructor (vtkHyperTreeGridNonOrientedGeometryCursor * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start(vtkHyperTreeGridNonOrientedGeometryCursor* sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local(vtkHyperTreeGridNonOrientedGeometryCursor* sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(vtkHyperTreeGridNonOrientedGeometryCursor* sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(vtkHyperTreeGridNonOrientedGeometryCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { sself->ToRoot(); } +extern "C" void vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(vtkHyperTreeGridNonOrientedGeometryCursor* sself) { sself->ToParent(); } +extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursor * vtkHyperTreeGridNonOrientedMooreSuperCursor_new () {return vtkHyperTreeGridNonOrientedMooreSuperCursor :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursor_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursor * sself) {sself -> Delete () ; return ;} +extern "C" vtkHyperTreeGridNonOrientedMooreSuperCursorLight * vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new () {return vtkHyperTreeGridNonOrientedMooreSuperCursorLight :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedMooreSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedMooreSuperCursorLight * sself) {sself -> Delete () ; return ;} +extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new () {return vtkHyperTreeGridNonOrientedVonNeumannSuperCursor :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursor * sself) {sself -> Delete () ; return ;} +extern "C" vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new () {return vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight :: New () ;} +extern "C" void vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_destructor (vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight * sself) {sself -> Delete () ; return ;} +extern "C" vtkHyperTreeGridOrientedCursor * vtkHyperTreeGridOrientedCursor_new () {return vtkHyperTreeGridOrientedCursor :: New () ;} +extern "C" void vtkHyperTreeGridOrientedCursor_destructor (vtkHyperTreeGridOrientedCursor * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_has_tree(vtkHyperTreeGridOrientedCursor* sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_dimension(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(vtkHyperTreeGridOrientedCursor* sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local(vtkHyperTreeGridOrientedCursor* sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_set_mask(vtkHyperTreeGridOrientedCursor* sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_masked(vtkHyperTreeGridOrientedCursor* sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_leaf(vtkHyperTreeGridOrientedCursor* sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(vtkHyperTreeGridOrientedCursor* sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_oriented_cursor_is_root(vtkHyperTreeGridOrientedCursor* sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_oriented_cursor_get_level(vtkHyperTreeGridOrientedCursor* sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_oriented_cursor_to_child(vtkHyperTreeGridOrientedCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" vtkHyperTreeGridOrientedGeometryCursor * vtkHyperTreeGridOrientedGeometryCursor_new () {return vtkHyperTreeGridOrientedGeometryCursor :: New () ;} +extern "C" void vtkHyperTreeGridOrientedGeometryCursor_destructor (vtkHyperTreeGridOrientedGeometryCursor * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->HasTree(); } +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetVertexId(); } +extern "C" long long vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetGlobalNodeIndex(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetDimension(); } +extern "C" unsigned char vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetNumberOfChildren(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start(vtkHyperTreeGridOrientedGeometryCursor* sself, long long index) { sself->SetGlobalIndexStart(index); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local(vtkHyperTreeGridOrientedGeometryCursor* sself, long long index) { sself->SetGlobalIndexFromLocal(index); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(vtkHyperTreeGridOrientedGeometryCursor* sself, bool state) { sself->SetMask(state); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->IsMasked(); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->IsLeaf(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(vtkHyperTreeGridOrientedGeometryCursor* sself) { sself->SubdivideLeaf(); } +extern "C" bool vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->IsRoot(); } +extern "C" unsigned int vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(vtkHyperTreeGridOrientedGeometryCursor* sself) { return sself->GetLevel(); } +extern "C" void vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(vtkHyperTreeGridOrientedGeometryCursor* sself, unsigned char ichild) { sself->ToChild(ichild); } +extern "C" vtkImageData * vtkImageData_new () {return vtkImageData :: New () ;} +extern "C" void vtkImageData_destructor (vtkImageData * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_image_data_get_data_object_type(vtkImageData* sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_image_data_get_number_of_cells(vtkImageData* sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_image_data_get_number_of_points(vtkImageData* sself) { return sself->GetNumberOfPoints(); } +extern "C" long long vtk_image_data_find_point(vtkImageData* sself, double x, double y, double z) { return sself->FindPoint(x, y, z); } +extern "C" int vtk_image_data_get_cell_type(vtkImageData* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_image_data_get_max_cell_size(vtkImageData* sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_image_data_initialize(vtkImageData* sself) { sself->Initialize(); } +extern "C" unsigned char vtk_image_data_is_point_visible(vtkImageData* sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_image_data_is_cell_visible(vtkImageData* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_image_data_has_any_blank_points(vtkImageData* sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_image_data_has_any_blank_cells(vtkImageData* sself) { return sself->HasAnyBlankCells(); } +extern "C" void vtk_image_data_set_dimensions(vtkImageData* sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" int vtk_image_data_get_data_dimension(vtkImageData* sself) { return sself->GetDataDimension(); } +extern "C" void vtk_image_data_set_extent(vtkImageData* sself, int x1, int x2, int y1, int y2, int z1, int z2) { sself->SetExtent(x1, x2, y1, y2, z1, z2); } +extern "C" void* vtk_image_data_get_scalar_pointer(vtkImageData* sself, int x, int y, int z) { return sself->GetScalarPointer(x, y, z); } +extern "C" long long vtk_image_data_get_scalar_index(vtkImageData* sself, int x, int y, int z) { return sself->GetScalarIndex(x, y, z); } +extern "C" float vtk_image_data_get_scalar_component_as_float(vtkImageData* sself, int x, int y, int z, int component) { return sself->GetScalarComponentAsFloat(x, y, z, component); } +extern "C" void vtk_image_data_set_scalar_component_from_float(vtkImageData* sself, int x, int y, int z, int component, float v) { sself->SetScalarComponentFromFloat(x, y, z, component, v); } +extern "C" double vtk_image_data_get_scalar_component_as_double(vtkImageData* sself, int x, int y, int z, int component) { return sself->GetScalarComponentAsDouble(x, y, z, component); } +extern "C" void vtk_image_data_set_scalar_component_from_double(vtkImageData* sself, int x, int y, int z, int component, double v) { sself->SetScalarComponentFromDouble(x, y, z, component, v); } +extern "C" void vtk_image_data_allocate_scalars(vtkImageData* sself, int dataType, int numComponents) { sself->AllocateScalars(dataType, numComponents); } +extern "C" void vtk_image_data_set_spacing(vtkImageData* sself, double i, double j, double k) { sself->SetSpacing(i, j, k); } +extern "C" void vtk_image_data_set_origin(vtkImageData* sself, double i, double j, double k) { sself->SetOrigin(i, j, k); } +extern "C" const char* vtk_image_data_get_scalar_type_as_string(vtkImageData* sself) { return sself->GetScalarTypeAsString(); } +extern "C" void vtk_image_data_prepare_for_new_data(vtkImageData* sself) { sself->PrepareForNewData(); } +extern "C" int vtk_image_data_get_extent_type(vtkImageData* sself) { return sself->GetExtentType(); } +extern "C" vtkImageTransform * vtkImageTransform_new () {return vtkImageTransform :: New () ;} +extern "C" void vtkImageTransform_destructor (vtkImageTransform * sself) {sself -> Delete () ; return ;} +extern "C" vtkImplicitBoolean * vtkImplicitBoolean_new () {return vtkImplicitBoolean :: New () ;} +extern "C" void vtkImplicitBoolean_destructor (vtkImplicitBoolean * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_implicit_boolean_get_m_time(vtkImplicitBoolean* sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_boolean_set_operation_type(vtkImplicitBoolean* sself, int _arg) { sself->SetOperationType(_arg); } +extern "C" int vtk_implicit_boolean_get_operation_type_min_value(vtkImplicitBoolean* sself) { return sself->GetOperationTypeMinValue(); } +extern "C" int vtk_implicit_boolean_get_operation_type_max_value(vtkImplicitBoolean* sself) { return sself->GetOperationTypeMaxValue(); } +extern "C" int vtk_implicit_boolean_get_operation_type(vtkImplicitBoolean* sself) { return sself->GetOperationType(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_union(vtkImplicitBoolean* sself) { sself->SetOperationTypeToUnion(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_intersection(vtkImplicitBoolean* sself) { sself->SetOperationTypeToIntersection(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_difference(vtkImplicitBoolean* sself) { sself->SetOperationTypeToDifference(); } +extern "C" void vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(vtkImplicitBoolean* sself) { sself->SetOperationTypeToUnionOfMagnitudes(); } +extern "C" const char* vtk_implicit_boolean_get_operation_type_as_string(vtkImplicitBoolean* sself) { return sself->GetOperationTypeAsString(); } +extern "C" vtkImplicitDataSet * vtkImplicitDataSet_new () {return vtkImplicitDataSet :: New () ;} +extern "C" void vtkImplicitDataSet_destructor (vtkImplicitDataSet * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_implicit_data_set_get_m_time(vtkImplicitDataSet* sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_data_set_set_out_value(vtkImplicitDataSet* sself, double _arg) { sself->SetOutValue(_arg); } +extern "C" double vtk_implicit_data_set_get_out_value(vtkImplicitDataSet* sself) { return sself->GetOutValue(); } +extern "C" void vtk_implicit_data_set_set_out_gradient(vtkImplicitDataSet* sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } +extern "C" vtkImplicitFunctionCollection * vtkImplicitFunctionCollection_new () {return vtkImplicitFunctionCollection :: New () ;} +extern "C" void vtkImplicitFunctionCollection_destructor (vtkImplicitFunctionCollection * sself) {sself -> Delete () ; return ;} +extern "C" vtkImplicitHalo * vtkImplicitHalo_new () {return vtkImplicitHalo :: New () ;} +extern "C" void vtkImplicitHalo_destructor (vtkImplicitHalo * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_implicit_halo_set_radius(vtkImplicitHalo* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_implicit_halo_get_radius(vtkImplicitHalo* sself) { return sself->GetRadius(); } +extern "C" void vtk_implicit_halo_set_center(vtkImplicitHalo* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_implicit_halo_set_fade_out(vtkImplicitHalo* sself, double _arg) { sself->SetFadeOut(_arg); } +extern "C" double vtk_implicit_halo_get_fade_out(vtkImplicitHalo* sself) { return sself->GetFadeOut(); } +extern "C" vtkImplicitSelectionLoop * vtkImplicitSelectionLoop_new () {return vtkImplicitSelectionLoop :: New () ;} +extern "C" void vtkImplicitSelectionLoop_destructor (vtkImplicitSelectionLoop * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_implicit_selection_loop_set_automatic_normal_generation(vtkImplicitSelectionLoop* sself, int _arg) { sself->SetAutomaticNormalGeneration(_arg); } +extern "C" int vtk_implicit_selection_loop_get_automatic_normal_generation(vtkImplicitSelectionLoop* sself) { return sself->GetAutomaticNormalGeneration(); } +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_on(vtkImplicitSelectionLoop* sself) { sself->AutomaticNormalGenerationOn(); } +extern "C" void vtk_implicit_selection_loop_automatic_normal_generation_off(vtkImplicitSelectionLoop* sself) { sself->AutomaticNormalGenerationOff(); } +extern "C" void vtk_implicit_selection_loop_set_normal(vtkImplicitSelectionLoop* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" unsigned long vtk_implicit_selection_loop_get_m_time(vtkImplicitSelectionLoop* sself) { return sself->GetMTime(); } +extern "C" vtkImplicitSum * vtkImplicitSum_new () {return vtkImplicitSum :: New () ;} +extern "C" void vtkImplicitSum_destructor (vtkImplicitSum * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_implicit_sum_get_m_time(vtkImplicitSum* sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_sum_remove_all_functions(vtkImplicitSum* sself) { sself->RemoveAllFunctions(); } +extern "C" void vtk_implicit_sum_set_normalize_by_weight(vtkImplicitSum* sself, int _arg) { sself->SetNormalizeByWeight(_arg); } +extern "C" int vtk_implicit_sum_get_normalize_by_weight(vtkImplicitSum* sself) { return sself->GetNormalizeByWeight(); } +extern "C" void vtk_implicit_sum_normalize_by_weight_on(vtkImplicitSum* sself) { sself->NormalizeByWeightOn(); } +extern "C" void vtk_implicit_sum_normalize_by_weight_off(vtkImplicitSum* sself) { sself->NormalizeByWeightOff(); } +extern "C" vtkImplicitVolume * vtkImplicitVolume_new () {return vtkImplicitVolume :: New () ;} +extern "C" void vtkImplicitVolume_destructor (vtkImplicitVolume * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_implicit_volume_get_m_time(vtkImplicitVolume* sself) { return sself->GetMTime(); } +extern "C" void vtk_implicit_volume_set_out_value(vtkImplicitVolume* sself, double _arg) { sself->SetOutValue(_arg); } +extern "C" double vtk_implicit_volume_get_out_value(vtkImplicitVolume* sself) { return sself->GetOutValue(); } +extern "C" void vtk_implicit_volume_set_out_gradient(vtkImplicitVolume* sself, double _arg1, double _arg2, double _arg3) { sself->SetOutGradient(_arg1, _arg2, _arg3); } +extern "C" vtkImplicitWindowFunction * vtkImplicitWindowFunction_new () {return vtkImplicitWindowFunction :: New () ;} +extern "C" void vtkImplicitWindowFunction_destructor (vtkImplicitWindowFunction * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_implicit_window_function_set_window_range(vtkImplicitWindowFunction* sself, double _arg1, double _arg2) { sself->SetWindowRange(_arg1, _arg2); } +extern "C" void vtk_implicit_window_function_set_window_values(vtkImplicitWindowFunction* sself, double _arg1, double _arg2) { sself->SetWindowValues(_arg1, _arg2); } +extern "C" unsigned long vtk_implicit_window_function_get_m_time(vtkImplicitWindowFunction* sself) { return sself->GetMTime(); } +extern "C" vtkInEdgeIterator * vtkInEdgeIterator_new () {return vtkInEdgeIterator :: New () ;} +extern "C" void vtkInEdgeIterator_destructor (vtkInEdgeIterator * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_in_edge_iterator_get_vertex(vtkInEdgeIterator* sself) { return sself->GetVertex(); } +extern "C" bool vtk_in_edge_iterator_has_next(vtkInEdgeIterator* sself) { return sself->HasNext(); } +extern "C" vtkIncrementalOctreeNode * vtkIncrementalOctreeNode_new () {return vtkIncrementalOctreeNode :: New () ;} +extern "C" void vtkIncrementalOctreeNode_destructor (vtkIncrementalOctreeNode * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_incremental_octree_node_get_number_of_points(vtkIncrementalOctreeNode* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_incremental_octree_node_delete_child_nodes(vtkIncrementalOctreeNode* sself) { sself->DeleteChildNodes(); } +extern "C" void vtk_incremental_octree_node_set_bounds(vtkIncrementalOctreeNode* sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } +extern "C" int vtk_incremental_octree_node_is_leaf(vtkIncrementalOctreeNode* sself) { return sself->IsLeaf(); } +extern "C" int vtk_incremental_octree_node_get_number_of_levels(vtkIncrementalOctreeNode* sself) { return sself->GetNumberOfLevels(); } +extern "C" int vtk_incremental_octree_node_get_id(vtkIncrementalOctreeNode* sself) { return sself->GetID(); } +extern "C" vtkIncrementalOctreePointLocator * vtkIncrementalOctreePointLocator_new () {return vtkIncrementalOctreePointLocator :: New () ;} +extern "C" void vtkIncrementalOctreePointLocator_destructor (vtkIncrementalOctreePointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_incremental_octree_point_locator_set_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself, int _arg) { sself->SetMaxPointsPerLeaf(_arg); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value(vtkIncrementalOctreePointLocator* sself) { return sself->GetMaxPointsPerLeafMinValue(); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value(vtkIncrementalOctreePointLocator* sself) { return sself->GetMaxPointsPerLeafMaxValue(); } +extern "C" int vtk_incremental_octree_point_locator_get_max_points_per_leaf(vtkIncrementalOctreePointLocator* sself) { return sself->GetMaxPointsPerLeaf(); } +extern "C" void vtk_incremental_octree_point_locator_set_build_cubic_octree(vtkIncrementalOctreePointLocator* sself, int _arg) { sself->SetBuildCubicOctree(_arg); } +extern "C" int vtk_incremental_octree_point_locator_get_build_cubic_octree(vtkIncrementalOctreePointLocator* sself) { return sself->GetBuildCubicOctree(); } +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_on(vtkIncrementalOctreePointLocator* sself) { sself->BuildCubicOctreeOn(); } +extern "C" void vtk_incremental_octree_point_locator_build_cubic_octree_off(vtkIncrementalOctreePointLocator* sself) { sself->BuildCubicOctreeOff(); } +extern "C" void vtk_incremental_octree_point_locator_initialize(vtkIncrementalOctreePointLocator* sself) { sself->Initialize(); } +extern "C" void vtk_incremental_octree_point_locator_free_search_structure(vtkIncrementalOctreePointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_points(vtkIncrementalOctreePointLocator* sself) { return sself->GetNumberOfPoints(); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_nodes(vtkIncrementalOctreePointLocator* sself) { return sself->GetNumberOfNodes(); } +extern "C" void vtk_incremental_octree_point_locator_build_locator(vtkIncrementalOctreePointLocator* sself) { sself->BuildLocator(); } +extern "C" long long vtk_incremental_octree_point_locator_find_closest_point(vtkIncrementalOctreePointLocator* sself, double x, double y, double z) { return sself->FindClosestPoint(x, y, z); } +extern "C" long long vtk_incremental_octree_point_locator_is_inserted_point(vtkIncrementalOctreePointLocator* sself, double x, double y, double z) { return sself->IsInsertedPoint(x, y, z); } +extern "C" int vtk_incremental_octree_point_locator_get_number_of_levels(vtkIncrementalOctreePointLocator* sself) { return sself->GetNumberOfLevels(); } +extern "C" vtkIterativeClosestPointTransform * vtkIterativeClosestPointTransform_new () {return vtkIterativeClosestPointTransform :: New () ;} +extern "C" void vtkIterativeClosestPointTransform_destructor (vtkIterativeClosestPointTransform * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetMaximumNumberOfIterations(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_iterations(vtkIterativeClosestPointTransform* sself) { return sself->GetMaximumNumberOfIterations(); } +extern "C" int vtk_iterative_closest_point_transform_get_number_of_iterations(vtkIterativeClosestPointTransform* sself) { return sself->GetNumberOfIterations(); } +extern "C" void vtk_iterative_closest_point_transform_set_check_mean_distance(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetCheckMeanDistance(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_check_mean_distance(vtkIterativeClosestPointTransform* sself) { return sself->GetCheckMeanDistance(); } +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_on(vtkIterativeClosestPointTransform* sself) { sself->CheckMeanDistanceOn(); } +extern "C" void vtk_iterative_closest_point_transform_check_mean_distance_off(vtkIterativeClosestPointTransform* sself) { sself->CheckMeanDistanceOff(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetMeanDistanceMode(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistanceModeMinValue(); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistanceModeMaxValue(); } +extern "C" int vtk_iterative_closest_point_transform_get_mean_distance_mode(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistanceMode(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(vtkIterativeClosestPointTransform* sself) { sself->SetMeanDistanceModeToRMS(); } +extern "C" void vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value(vtkIterativeClosestPointTransform* sself) { sself->SetMeanDistanceModeToAbsoluteValue(); } +extern "C" const char* vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistanceModeAsString(); } +extern "C" void vtk_iterative_closest_point_transform_set_maximum_mean_distance(vtkIterativeClosestPointTransform* sself, double _arg) { sself->SetMaximumMeanDistance(_arg); } +extern "C" double vtk_iterative_closest_point_transform_get_maximum_mean_distance(vtkIterativeClosestPointTransform* sself) { return sself->GetMaximumMeanDistance(); } +extern "C" double vtk_iterative_closest_point_transform_get_mean_distance(vtkIterativeClosestPointTransform* sself) { return sself->GetMeanDistance(); } +extern "C" void vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetMaximumNumberOfLandmarks(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(vtkIterativeClosestPointTransform* sself) { return sself->GetMaximumNumberOfLandmarks(); } +extern "C" void vtk_iterative_closest_point_transform_set_start_by_matching_centroids(vtkIterativeClosestPointTransform* sself, int _arg) { sself->SetStartByMatchingCentroids(_arg); } +extern "C" int vtk_iterative_closest_point_transform_get_start_by_matching_centroids(vtkIterativeClosestPointTransform* sself) { return sself->GetStartByMatchingCentroids(); } +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_on(vtkIterativeClosestPointTransform* sself) { sself->StartByMatchingCentroidsOn(); } +extern "C" void vtk_iterative_closest_point_transform_start_by_matching_centroids_off(vtkIterativeClosestPointTransform* sself) { sself->StartByMatchingCentroidsOff(); } +extern "C" void vtk_iterative_closest_point_transform_inverse(vtkIterativeClosestPointTransform* sself) { sself->Inverse(); } +extern "C" vtkKdNode * vtkKdNode_new () {return vtkKdNode :: New () ;} +extern "C" void vtkKdNode_destructor (vtkKdNode * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_kd_node_set_dim(vtkKdNode* sself, int _arg) { sself->SetDim(_arg); } +extern "C" int vtk_kd_node_get_dim(vtkKdNode* sself) { return sself->GetDim(); } +extern "C" double vtk_kd_node_get_division_position(vtkKdNode* sself) { return sself->GetDivisionPosition(); } +extern "C" void vtk_kd_node_set_number_of_points(vtkKdNode* sself, int _arg) { sself->SetNumberOfPoints(_arg); } +extern "C" int vtk_kd_node_get_number_of_points(vtkKdNode* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_kd_node_set_bounds(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetBounds(x1, x2, y1, y2, z1, z2); } +extern "C" void vtk_kd_node_set_data_bounds(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2) { sself->SetDataBounds(x1, x2, y1, y2, z1, z2); } +extern "C" void vtk_kd_node_set_id(vtkKdNode* sself, int _arg) { sself->SetID(_arg); } +extern "C" int vtk_kd_node_get_id(vtkKdNode* sself) { return sself->GetID(); } +extern "C" int vtk_kd_node_get_min_id(vtkKdNode* sself) { return sself->GetMinID(); } +extern "C" int vtk_kd_node_get_max_id(vtkKdNode* sself) { return sself->GetMaxID(); } +extern "C" void vtk_kd_node_set_min_id(vtkKdNode* sself, int _arg) { sself->SetMinID(_arg); } +extern "C" void vtk_kd_node_set_max_id(vtkKdNode* sself, int _arg) { sself->SetMaxID(_arg); } +extern "C" void vtk_kd_node_delete_child_nodes(vtkKdNode* sself) { sself->DeleteChildNodes(); } +extern "C" int vtk_kd_node_intersects_box(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds) { return sself->IntersectsBox(x1, x2, y1, y2, z1, z2, useDataBounds); } +extern "C" int vtk_kd_node_intersects_sphere_2(vtkKdNode* sself, double x, double y, double z, double rSquared, int useDataBounds) { return sself->IntersectsSphere2(x, y, z, rSquared, useDataBounds); } +extern "C" int vtk_kd_node_contains_box(vtkKdNode* sself, double x1, double x2, double y1, double y2, double z1, double z2, int useDataBounds) { return sself->ContainsBox(x1, x2, y1, y2, z1, z2, useDataBounds); } +extern "C" int vtk_kd_node_contains_point(vtkKdNode* sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } +extern "C" double vtk_kd_node_get_distance_2_to_boundary(vtkKdNode* sself, double x, double y, double z, int useDataBounds) { return sself->GetDistance2ToBoundary(x, y, z, useDataBounds); } +extern "C" double vtk_kd_node_get_distance_2_to_inner_boundary(vtkKdNode* sself, double x, double y, double z) { return sself->GetDistance2ToInnerBoundary(x, y, z); } +extern "C" void vtk_kd_node_print_node(vtkKdNode* sself, int depth) { sself->PrintNode(depth); } +extern "C" void vtk_kd_node_print_verbose_node(vtkKdNode* sself, int depth) { sself->PrintVerboseNode(depth); } +extern "C" vtkKdTree * vtkKdTree_new () {return vtkKdTree :: New () ;} +extern "C" void vtkKdTree_destructor (vtkKdTree * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_kd_tree_timing_on(vtkKdTree* sself) { sself->TimingOn(); } +extern "C" void vtk_kd_tree_timing_off(vtkKdTree* sself) { sself->TimingOff(); } +extern "C" void vtk_kd_tree_set_timing(vtkKdTree* sself, int _arg) { sself->SetTiming(_arg); } +extern "C" int vtk_kd_tree_get_timing(vtkKdTree* sself) { return sself->GetTiming(); } +extern "C" void vtk_kd_tree_set_min_cells(vtkKdTree* sself, int _arg) { sself->SetMinCells(_arg); } +extern "C" int vtk_kd_tree_get_min_cells(vtkKdTree* sself) { return sself->GetMinCells(); } +extern "C" int vtk_kd_tree_get_number_of_regions_or_less(vtkKdTree* sself) { return sself->GetNumberOfRegionsOrLess(); } +extern "C" void vtk_kd_tree_set_number_of_regions_or_less(vtkKdTree* sself, int _arg) { sself->SetNumberOfRegionsOrLess(_arg); } +extern "C" int vtk_kd_tree_get_number_of_regions_or_more(vtkKdTree* sself) { return sself->GetNumberOfRegionsOrMore(); } +extern "C" void vtk_kd_tree_set_number_of_regions_or_more(vtkKdTree* sself, int _arg) { sself->SetNumberOfRegionsOrMore(_arg); } +extern "C" double vtk_kd_tree_get_fudge_factor(vtkKdTree* sself) { return sself->GetFudgeFactor(); } +extern "C" void vtk_kd_tree_set_fudge_factor(vtkKdTree* sself, double _arg) { sself->SetFudgeFactor(_arg); } +extern "C" void vtk_kd_tree_omit_x_partitioning(vtkKdTree* sself) { sself->OmitXPartitioning(); } +extern "C" void vtk_kd_tree_omit_y_partitioning(vtkKdTree* sself) { sself->OmitYPartitioning(); } +extern "C" void vtk_kd_tree_omit_z_partitioning(vtkKdTree* sself) { sself->OmitZPartitioning(); } +extern "C" void vtk_kd_tree_omit_xy_partitioning(vtkKdTree* sself) { sself->OmitXYPartitioning(); } +extern "C" void vtk_kd_tree_omit_yz_partitioning(vtkKdTree* sself) { sself->OmitYZPartitioning(); } +extern "C" void vtk_kd_tree_omit_zx_partitioning(vtkKdTree* sself) { sself->OmitZXPartitioning(); } +extern "C" void vtk_kd_tree_omit_no_partitioning(vtkKdTree* sself) { sself->OmitNoPartitioning(); } +extern "C" void vtk_kd_tree_remove_data_set(vtkKdTree* sself, int index) { sself->RemoveDataSet(index); } +extern "C" void vtk_kd_tree_remove_all_data_sets(vtkKdTree* sself) { sself->RemoveAllDataSets(); } +extern "C" int vtk_kd_tree_get_number_of_data_sets(vtkKdTree* sself) { return sself->GetNumberOfDataSets(); } +extern "C" int vtk_kd_tree_get_number_of_regions(vtkKdTree* sself) { return sself->GetNumberOfRegions(); } +extern "C" void vtk_kd_tree_print_tree(vtkKdTree* sself) { sself->PrintTree(); } +extern "C" void vtk_kd_tree_print_verbose_tree(vtkKdTree* sself) { sself->PrintVerboseTree(); } +extern "C" void vtk_kd_tree_print_region(vtkKdTree* sself, int id) { sself->PrintRegion(id); } +extern "C" void vtk_kd_tree_set_include_region_boundary_cells(vtkKdTree* sself, int _arg) { sself->SetIncludeRegionBoundaryCells(_arg); } +extern "C" int vtk_kd_tree_get_include_region_boundary_cells(vtkKdTree* sself) { return sself->GetIncludeRegionBoundaryCells(); } +extern "C" void vtk_kd_tree_include_region_boundary_cells_on(vtkKdTree* sself) { sself->IncludeRegionBoundaryCellsOn(); } +extern "C" void vtk_kd_tree_include_region_boundary_cells_off(vtkKdTree* sself) { sself->IncludeRegionBoundaryCellsOff(); } +extern "C" void vtk_kd_tree_delete_cell_lists(vtkKdTree* sself) { sself->DeleteCellLists(); } +extern "C" int vtk_kd_tree_get_region_containing_point(vtkKdTree* sself, double x, double y, double z) { return sself->GetRegionContainingPoint(x, y, z); } +extern "C" void vtk_kd_tree_build_locator(vtkKdTree* sself) { sself->BuildLocator(); } +extern "C" void vtk_kd_tree_free_search_structure(vtkKdTree* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_on(vtkKdTree* sself) { sself->GenerateRepresentationUsingDataBoundsOn(); } +extern "C" void vtk_kd_tree_generate_representation_using_data_bounds_off(vtkKdTree* sself) { sself->GenerateRepresentationUsingDataBoundsOff(); } +extern "C" void vtk_kd_tree_set_generate_representation_using_data_bounds(vtkKdTree* sself, int _arg) { sself->SetGenerateRepresentationUsingDataBounds(_arg); } +extern "C" int vtk_kd_tree_get_generate_representation_using_data_bounds(vtkKdTree* sself) { return sself->GetGenerateRepresentationUsingDataBounds(); } +extern "C" int vtk_kd_tree_new_geometry(vtkKdTree* sself) { return sself->NewGeometry(); } +extern "C" void vtk_kd_tree_invalidate_geometry(vtkKdTree* sself) { sself->InvalidateGeometry(); } +extern "C" vtkKdTreePointLocator * vtkKdTreePointLocator_new () {return vtkKdTreePointLocator :: New () ;} +extern "C" void vtkKdTreePointLocator_destructor (vtkKdTreePointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_kd_tree_point_locator_free_search_structure(vtkKdTreePointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_kd_tree_point_locator_build_locator(vtkKdTreePointLocator* sself) { sself->BuildLocator(); } +extern "C" vtkLagrangeCurve * vtkLagrangeCurve_new () {return vtkLagrangeCurve :: New () ;} +extern "C" void vtkLagrangeCurve_destructor (vtkLagrangeCurve * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_lagrange_curve_get_cell_type(vtkLagrangeCurve* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeHexahedron * vtkLagrangeHexahedron_new () {return vtkLagrangeHexahedron :: New () ;} +extern "C" void vtkLagrangeHexahedron_destructor (vtkLagrangeHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_lagrange_hexahedron_get_cell_type(vtkLagrangeHexahedron* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeInterpolation * vtkLagrangeInterpolation_new () {return vtkLagrangeInterpolation :: New () ;} +extern "C" void vtkLagrangeInterpolation_destructor (vtkLagrangeInterpolation * sself) {sself -> Delete () ; return ;} +extern "C" vtkLagrangeQuadrilateral * vtkLagrangeQuadrilateral_new () {return vtkLagrangeQuadrilateral :: New () ;} +extern "C" void vtkLagrangeQuadrilateral_destructor (vtkLagrangeQuadrilateral * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_lagrange_quadrilateral_get_cell_type(vtkLagrangeQuadrilateral* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeTetra * vtkLagrangeTetra_new () {return vtkLagrangeTetra :: New () ;} +extern "C" void vtkLagrangeTetra_destructor (vtkLagrangeTetra * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_lagrange_tetra_get_cell_type(vtkLagrangeTetra* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeTriangle * vtkLagrangeTriangle_new () {return vtkLagrangeTriangle :: New () ;} +extern "C" void vtkLagrangeTriangle_destructor (vtkLagrangeTriangle * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_lagrange_triangle_get_cell_type(vtkLagrangeTriangle* sself) { return sself->GetCellType(); } +extern "C" vtkLagrangeWedge * vtkLagrangeWedge_new () {return vtkLagrangeWedge :: New () ;} +extern "C" void vtkLagrangeWedge_destructor (vtkLagrangeWedge * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_lagrange_wedge_get_cell_type(vtkLagrangeWedge* sself) { return sself->GetCellType(); } +extern "C" vtkLine * vtkLine_new () {return vtkLine :: New () ;} +extern "C" void vtkLine_destructor (vtkLine * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_line_get_cell_type(vtkLine* sself) { return sself->GetCellType(); } +extern "C" int vtk_line_get_cell_dimension(vtkLine* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_line_get_number_of_edges(vtkLine* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_line_get_number_of_faces(vtkLine* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_line_inflate(vtkLine* sself, double dist) { return sself->Inflate(dist); } +extern "C" vtkMeanValueCoordinatesInterpolator * vtkMeanValueCoordinatesInterpolator_new () {return vtkMeanValueCoordinatesInterpolator :: New () ;} +extern "C" void vtkMeanValueCoordinatesInterpolator_destructor (vtkMeanValueCoordinatesInterpolator * sself) {sself -> Delete () ; return ;} +extern "C" vtkMergePoints * vtkMergePoints_new () {return vtkMergePoints :: New () ;} +extern "C" void vtkMergePoints_destructor (vtkMergePoints * sself) {sself -> Delete () ; return ;} +extern "C" vtkMolecule * vtkMolecule_new () {return vtkMolecule :: New () ;} +extern "C" void vtkMolecule_destructor (vtkMolecule * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_molecule_get_number_of_atoms(vtkMolecule* sself) { return sself->GetNumberOfAtoms(); } +extern "C" long long vtk_molecule_get_number_of_bonds(vtkMolecule* sself) { return sself->GetNumberOfBonds(); } +extern "C" unsigned short vtk_molecule_get_atom_atomic_number(vtkMolecule* sself, long long atomId) { return sself->GetAtomAtomicNumber(atomId); } +extern "C" void vtk_molecule_set_atom_atomic_number(vtkMolecule* sself, long long atomId, unsigned short atomicNum) { sself->SetAtomAtomicNumber(atomId, atomicNum); } +extern "C" void vtk_molecule_set_bond_order(vtkMolecule* sself, long long bondId, unsigned short order) { sself->SetBondOrder(bondId, order); } +extern "C" unsigned short vtk_molecule_get_bond_order(vtkMolecule* sself, long long bondId) { return sself->GetBondOrder(bondId); } +extern "C" double vtk_molecule_get_bond_length(vtkMolecule* sself, long long bondId) { return sself->GetBondLength(bondId); } +extern "C" bool vtk_molecule_has_lattice(vtkMolecule* sself) { return sself->HasLattice(); } +extern "C" void vtk_molecule_clear_lattice(vtkMolecule* sself) { sself->ClearLattice(); } +extern "C" void vtk_molecule_allocate_atom_ghost_array(vtkMolecule* sself) { sself->AllocateAtomGhostArray(); } +extern "C" void vtk_molecule_allocate_bond_ghost_array(vtkMolecule* sself) { sself->AllocateBondGhostArray(); } +extern "C" long long vtk_molecule_get_bond_id(vtkMolecule* sself, long long a, long long b) { return sself->GetBondId(a, b); } +extern "C" void vtk_molecule_set_atomic_number_array_name(vtkMolecule* sself, const char* _arg) { sself->SetAtomicNumberArrayName(_arg); } +extern "C" void vtk_molecule_set_bond_orders_array_name(vtkMolecule* sself, const char* _arg) { sself->SetBondOrdersArrayName(_arg); } +extern "C" vtkMultiBlockDataSet * vtkMultiBlockDataSet_new () {return vtkMultiBlockDataSet :: New () ;} +extern "C" void vtkMultiBlockDataSet_destructor (vtkMultiBlockDataSet * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_multi_block_data_set_set_number_of_blocks(vtkMultiBlockDataSet* sself, unsigned int numBlocks) { sself->SetNumberOfBlocks(numBlocks); } +extern "C" unsigned int vtk_multi_block_data_set_get_number_of_blocks(vtkMultiBlockDataSet* sself) { return sself->GetNumberOfBlocks(); } +extern "C" void vtk_multi_block_data_set_remove_block(vtkMultiBlockDataSet* sself, unsigned int blockno) { sself->RemoveBlock(blockno); } +extern "C" int vtk_multi_block_data_set_has_meta_data(vtkMultiBlockDataSet* sself, unsigned int blockno) { return sself->HasMetaData(blockno); } +extern "C" vtkMultiPieceDataSet * vtkMultiPieceDataSet_new () {return vtkMultiPieceDataSet :: New () ;} +extern "C" void vtkMultiPieceDataSet_destructor (vtkMultiPieceDataSet * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_multi_piece_data_set_set_number_of_pieces(vtkMultiPieceDataSet* sself, unsigned int numpieces) { sself->SetNumberOfPieces(numpieces); } +extern "C" unsigned int vtk_multi_piece_data_set_get_number_of_pieces(vtkMultiPieceDataSet* sself) { return sself->GetNumberOfPieces(); } +extern "C" vtkMutableDirectedGraph * vtkMutableDirectedGraph_new () {return vtkMutableDirectedGraph :: New () ;} +extern "C" void vtkMutableDirectedGraph_destructor (vtkMutableDirectedGraph * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_mutable_directed_graph_set_number_of_vertices(vtkMutableDirectedGraph* sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } +extern "C" long long vtk_mutable_directed_graph_add_vertex(vtkMutableDirectedGraph* sself) { return sself->AddVertex(); } +extern "C" void vtk_mutable_directed_graph_lazy_add_vertex(vtkMutableDirectedGraph* sself) { sself->LazyAddVertex(); } +extern "C" void vtk_mutable_directed_graph_remove_vertex(vtkMutableDirectedGraph* sself, long long v) { sself->RemoveVertex(v); } +extern "C" void vtk_mutable_directed_graph_remove_edge(vtkMutableDirectedGraph* sself, long long e) { sself->RemoveEdge(e); } +extern "C" vtkMutableUndirectedGraph * vtkMutableUndirectedGraph_new () {return vtkMutableUndirectedGraph :: New () ;} +extern "C" void vtkMutableUndirectedGraph_destructor (vtkMutableUndirectedGraph * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_mutable_undirected_graph_set_number_of_vertices(vtkMutableUndirectedGraph* sself, long long numVerts) { return sself->SetNumberOfVertices(numVerts); } +extern "C" long long vtk_mutable_undirected_graph_add_vertex(vtkMutableUndirectedGraph* sself) { return sself->AddVertex(); } +extern "C" void vtk_mutable_undirected_graph_lazy_add_vertex(vtkMutableUndirectedGraph* sself) { sself->LazyAddVertex(); } +extern "C" void vtk_mutable_undirected_graph_lazy_add_edge(vtkMutableUndirectedGraph* sself, long long u, long long v) { sself->LazyAddEdge(u, v); } +extern "C" void vtk_mutable_undirected_graph_remove_vertex(vtkMutableUndirectedGraph* sself, long long v) { sself->RemoveVertex(v); } +extern "C" void vtk_mutable_undirected_graph_remove_edge(vtkMutableUndirectedGraph* sself, long long e) { sself->RemoveEdge(e); } +extern "C" vtkNonMergingPointLocator * vtkNonMergingPointLocator_new () {return vtkNonMergingPointLocator :: New () ;} +extern "C" void vtkNonMergingPointLocator_destructor (vtkNonMergingPointLocator * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_non_merging_point_locator_is_inserted_point(vtkNonMergingPointLocator* sself, double p0, double p1, double p2) { return sself->IsInsertedPoint(p0, p1, p2); } +extern "C" vtkNonOverlappingAMR * vtkNonOverlappingAMR_new () {return vtkNonOverlappingAMR :: New () ;} +extern "C" void vtkNonOverlappingAMR_destructor (vtkNonOverlappingAMR * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_non_overlapping_amr_get_data_object_type(vtkNonOverlappingAMR* sself) { return sself->GetDataObjectType(); } +extern "C" vtkOctreePointLocator * vtkOctreePointLocator_new () {return vtkOctreePointLocator :: New () ;} +extern "C" void vtkOctreePointLocator_destructor (vtkOctreePointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_octree_point_locator_set_maximum_points_per_region(vtkOctreePointLocator* sself, int _arg) { sself->SetMaximumPointsPerRegion(_arg); } +extern "C" int vtk_octree_point_locator_get_maximum_points_per_region(vtkOctreePointLocator* sself) { return sself->GetMaximumPointsPerRegion(); } +extern "C" void vtk_octree_point_locator_set_create_cubic_octants(vtkOctreePointLocator* sself, int _arg) { sself->SetCreateCubicOctants(_arg); } +extern "C" int vtk_octree_point_locator_get_create_cubic_octants(vtkOctreePointLocator* sself) { return sself->GetCreateCubicOctants(); } +extern "C" double vtk_octree_point_locator_get_fudge_factor(vtkOctreePointLocator* sself) { return sself->GetFudgeFactor(); } +extern "C" void vtk_octree_point_locator_set_fudge_factor(vtkOctreePointLocator* sself, double _arg) { sself->SetFudgeFactor(_arg); } +extern "C" int vtk_octree_point_locator_get_number_of_leaf_nodes(vtkOctreePointLocator* sself) { return sself->GetNumberOfLeafNodes(); } +extern "C" int vtk_octree_point_locator_get_region_containing_point(vtkOctreePointLocator* sself, double x, double y, double z) { return sself->GetRegionContainingPoint(x, y, z); } +extern "C" void vtk_octree_point_locator_build_locator(vtkOctreePointLocator* sself) { sself->BuildLocator(); } +extern "C" long long vtk_octree_point_locator_find_closest_point(vtkOctreePointLocator* sself, double x, double y, double z, double& dist2) { return sself->FindClosestPoint(x, y, z, dist2); } +extern "C" void vtk_octree_point_locator_free_search_structure(vtkOctreePointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" vtkOctreePointLocatorNode * vtkOctreePointLocatorNode_new () {return vtkOctreePointLocatorNode :: New () ;} +extern "C" void vtkOctreePointLocatorNode_destructor (vtkOctreePointLocatorNode * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_octree_point_locator_node_set_number_of_points(vtkOctreePointLocatorNode* sself, int numberOfPoints) { sself->SetNumberOfPoints(numberOfPoints); } +extern "C" int vtk_octree_point_locator_node_get_number_of_points(vtkOctreePointLocatorNode* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_octree_point_locator_node_set_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_octree_point_locator_node_set_data_bounds(vtkOctreePointLocatorNode* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetDataBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" int vtk_octree_point_locator_node_get_id(vtkOctreePointLocatorNode* sself) { return sself->GetID(); } +extern "C" int vtk_octree_point_locator_node_get_min_id(vtkOctreePointLocatorNode* sself) { return sself->GetMinID(); } +extern "C" void vtk_octree_point_locator_node_create_child_nodes(vtkOctreePointLocatorNode* sself) { sself->CreateChildNodes(); } +extern "C" void vtk_octree_point_locator_node_delete_child_nodes(vtkOctreePointLocatorNode* sself) { sself->DeleteChildNodes(); } +extern "C" int vtk_octree_point_locator_node_contains_point(vtkOctreePointLocatorNode* sself, double x, double y, double z, int useDataBounds) { return sself->ContainsPoint(x, y, z, useDataBounds); } +extern "C" vtkOrderedTriangulator * vtkOrderedTriangulator_new () {return vtkOrderedTriangulator :: New () ;} +extern "C" void vtkOrderedTriangulator_destructor (vtkOrderedTriangulator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_ordered_triangulator_init_triangulation(vtkOrderedTriangulator* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int numPts) { sself->InitTriangulation(xmin, xmax, ymin, ymax, zmin, zmax, numPts); } +extern "C" void vtk_ordered_triangulator_triangulate(vtkOrderedTriangulator* sself) { sself->Triangulate(); } +extern "C" void vtk_ordered_triangulator_template_triangulate(vtkOrderedTriangulator* sself, int cellType, int numPts, int numEdges) { sself->TemplateTriangulate(cellType, numPts, numEdges); } +extern "C" void vtk_ordered_triangulator_update_point_type(vtkOrderedTriangulator* sself, long long internalId, int type) { sself->UpdatePointType(internalId, type); } +extern "C" long long vtk_ordered_triangulator_get_point_id(vtkOrderedTriangulator* sself, long long internalId) { return sself->GetPointId(internalId); } +extern "C" int vtk_ordered_triangulator_get_number_of_points(vtkOrderedTriangulator* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_ordered_triangulator_set_use_templates(vtkOrderedTriangulator* sself, int _arg) { sself->SetUseTemplates(_arg); } +extern "C" int vtk_ordered_triangulator_get_use_templates(vtkOrderedTriangulator* sself) { return sself->GetUseTemplates(); } +extern "C" void vtk_ordered_triangulator_use_templates_on(vtkOrderedTriangulator* sself) { sself->UseTemplatesOn(); } +extern "C" void vtk_ordered_triangulator_use_templates_off(vtkOrderedTriangulator* sself) { sself->UseTemplatesOff(); } +extern "C" void vtk_ordered_triangulator_set_pre_sorted(vtkOrderedTriangulator* sself, int _arg) { sself->SetPreSorted(_arg); } +extern "C" int vtk_ordered_triangulator_get_pre_sorted(vtkOrderedTriangulator* sself) { return sself->GetPreSorted(); } +extern "C" void vtk_ordered_triangulator_pre_sorted_on(vtkOrderedTriangulator* sself) { sself->PreSortedOn(); } +extern "C" void vtk_ordered_triangulator_pre_sorted_off(vtkOrderedTriangulator* sself) { sself->PreSortedOff(); } +extern "C" void vtk_ordered_triangulator_set_use_two_sort_ids(vtkOrderedTriangulator* sself, int _arg) { sself->SetUseTwoSortIds(_arg); } +extern "C" int vtk_ordered_triangulator_get_use_two_sort_ids(vtkOrderedTriangulator* sself) { return sself->GetUseTwoSortIds(); } +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_on(vtkOrderedTriangulator* sself) { sself->UseTwoSortIdsOn(); } +extern "C" void vtk_ordered_triangulator_use_two_sort_ids_off(vtkOrderedTriangulator* sself) { sself->UseTwoSortIdsOff(); } +extern "C" void vtk_ordered_triangulator_init_tetra_traversal(vtkOrderedTriangulator* sself) { sself->InitTetraTraversal(); } +extern "C" vtkOutEdgeIterator * vtkOutEdgeIterator_new () {return vtkOutEdgeIterator :: New () ;} +extern "C" void vtkOutEdgeIterator_destructor (vtkOutEdgeIterator * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_out_edge_iterator_get_vertex(vtkOutEdgeIterator* sself) { return sself->GetVertex(); } +extern "C" bool vtk_out_edge_iterator_has_next(vtkOutEdgeIterator* sself) { return sself->HasNext(); } +extern "C" vtkOverlappingAMR * vtkOverlappingAMR_new () {return vtkOverlappingAMR :: New () ;} +extern "C" void vtkOverlappingAMR_destructor (vtkOverlappingAMR * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_overlapping_amr_set_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level, int refRatio) { sself->SetRefinementRatio(level, refRatio); } +extern "C" int vtk_overlapping_amr_get_refinement_ratio(vtkOverlappingAMR* sself, unsigned int level) { return sself->GetRefinementRatio(level); } +extern "C" void vtk_overlapping_amr_set_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id, int sourceId) { sself->SetAMRBlockSourceIndex(level, id, sourceId); } +extern "C" int vtk_overlapping_amr_get_amr_block_source_index(vtkOverlappingAMR* sself, unsigned int level, unsigned int id) { return sself->GetAMRBlockSourceIndex(level, id); } +extern "C" bool vtk_overlapping_amr_has_children_information(vtkOverlappingAMR* sself) { return sself->HasChildrenInformation(); } +extern "C" void vtk_overlapping_amr_generate_parent_child_information(vtkOverlappingAMR* sself) { sself->GenerateParentChildInformation(); } +extern "C" void vtk_overlapping_amr_print_parent_child_info(vtkOverlappingAMR* sself, unsigned int level, unsigned int index) { sself->PrintParentChildInfo(level, index); } +extern "C" void vtk_overlapping_amr_audit(vtkOverlappingAMR* sself) { sself->Audit(); } +extern "C" vtkPartitionedDataSet * vtkPartitionedDataSet_new () {return vtkPartitionedDataSet :: New () ;} +extern "C" void vtkPartitionedDataSet_destructor (vtkPartitionedDataSet * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_partitioned_data_set_set_number_of_partitions(vtkPartitionedDataSet* sself, unsigned int numPartitions) { sself->SetNumberOfPartitions(numPartitions); } +extern "C" unsigned int vtk_partitioned_data_set_get_number_of_partitions(vtkPartitionedDataSet* sself) { return sself->GetNumberOfPartitions(); } +extern "C" int vtk_partitioned_data_set_has_meta_data(vtkPartitionedDataSet* sself, unsigned int idx) { return sself->HasMetaData(idx); } +extern "C" void vtk_partitioned_data_set_remove_null_partitions(vtkPartitionedDataSet* sself) { sself->RemoveNullPartitions(); } +extern "C" vtkPartitionedDataSetCollection * vtkPartitionedDataSetCollection_new () {return vtkPartitionedDataSetCollection :: New () ;} +extern "C" void vtkPartitionedDataSetCollection_destructor (vtkPartitionedDataSetCollection * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself, unsigned int numDataSets) { sself->SetNumberOfPartitionedDataSets(numDataSets); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets(vtkPartitionedDataSetCollection* sself) { return sself->GetNumberOfPartitionedDataSets(); } +extern "C" void vtk_partitioned_data_set_collection_remove_partitioned_data_set(vtkPartitionedDataSetCollection* sself, unsigned int idx) { sself->RemovePartitionedDataSet(idx); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_number_of_partitions(vtkPartitionedDataSetCollection* sself, unsigned int idx) { return sself->GetNumberOfPartitions(idx); } +extern "C" void vtk_partitioned_data_set_collection_set_number_of_partitions(vtkPartitionedDataSetCollection* sself, unsigned int idx, unsigned int numPartitions) { sself->SetNumberOfPartitions(idx, numPartitions); } +extern "C" int vtk_partitioned_data_set_collection_has_meta_data(vtkPartitionedDataSetCollection* sself, unsigned int idx) { return sself->HasMetaData(idx); } +extern "C" unsigned int vtk_partitioned_data_set_collection_get_composite_index(vtkPartitionedDataSetCollection* sself, unsigned int idx) { return sself->GetCompositeIndex(idx); } +extern "C" unsigned long vtk_partitioned_data_set_collection_get_m_time(vtkPartitionedDataSetCollection* sself) { return sself->GetMTime(); } +extern "C" vtkPath * vtkPath_new () {return vtkPath :: New () ;} +extern "C" void vtkPath_destructor (vtkPath * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_path_get_data_object_type(vtkPath* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_path_insert_next_point(vtkPath* sself, double x, double y, double z, int code) { sself->InsertNextPoint(x, y, z, code); } +extern "C" long long vtk_path_get_number_of_cells(vtkPath* sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_path_get_max_cell_size(vtkPath* sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_path_allocate(vtkPath* sself, long long size, int extSize) { sself->Allocate(size, extSize); } +extern "C" void vtk_path_reset(vtkPath* sself) { sself->Reset(); } +extern "C" vtkPentagonalPrism * vtkPentagonalPrism_new () {return vtkPentagonalPrism :: New () ;} +extern "C" void vtkPentagonalPrism_destructor (vtkPentagonalPrism * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_pentagonal_prism_get_cell_type(vtkPentagonalPrism* sself) { return sself->GetCellType(); } +extern "C" int vtk_pentagonal_prism_get_number_of_edges(vtkPentagonalPrism* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pentagonal_prism_get_number_of_faces(vtkPentagonalPrism* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkPerlinNoise * vtkPerlinNoise_new () {return vtkPerlinNoise :: New () ;} +extern "C" void vtkPerlinNoise_destructor (vtkPerlinNoise * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_perlin_noise_set_frequency(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3) { sself->SetFrequency(_arg1, _arg2, _arg3); } +extern "C" void vtk_perlin_noise_set_phase(vtkPerlinNoise* sself, double _arg1, double _arg2, double _arg3) { sself->SetPhase(_arg1, _arg2, _arg3); } +extern "C" void vtk_perlin_noise_set_amplitude(vtkPerlinNoise* sself, double _arg) { sself->SetAmplitude(_arg); } +extern "C" double vtk_perlin_noise_get_amplitude(vtkPerlinNoise* sself) { return sself->GetAmplitude(); } +extern "C" vtkPiecewiseFunction * vtkPiecewiseFunction_new () {return vtkPiecewiseFunction :: New () ;} +extern "C" void vtkPiecewiseFunction_destructor (vtkPiecewiseFunction * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_piecewise_function_get_data_object_type(vtkPiecewiseFunction* sself) { return sself->GetDataObjectType(); } +extern "C" int vtk_piecewise_function_get_size(vtkPiecewiseFunction* sself) { return sself->GetSize(); } +extern "C" int vtk_piecewise_function_add_point(vtkPiecewiseFunction* sself, double x, double y) { return sself->AddPoint(x, y); } +extern "C" bool vtk_piecewise_function_remove_point_by_index(vtkPiecewiseFunction* sself, size_t id) { return sself->RemovePointByIndex(id); } +extern "C" int vtk_piecewise_function_remove_point(vtkPiecewiseFunction* sself, double x) { return sself->RemovePoint(x); } +extern "C" void vtk_piecewise_function_remove_all_points(vtkPiecewiseFunction* sself) { sself->RemoveAllPoints(); } +extern "C" void vtk_piecewise_function_add_segment(vtkPiecewiseFunction* sself, double x1, double y1, double x2, double y2) { sself->AddSegment(x1, y1, x2, y2); } +extern "C" double vtk_piecewise_function_get_value(vtkPiecewiseFunction* sself, double x) { return sself->GetValue(x); } +extern "C" void vtk_piecewise_function_set_clamping(vtkPiecewiseFunction* sself, int _arg) { sself->SetClamping(_arg); } +extern "C" int vtk_piecewise_function_get_clamping(vtkPiecewiseFunction* sself) { return sself->GetClamping(); } +extern "C" void vtk_piecewise_function_clamping_on(vtkPiecewiseFunction* sself) { sself->ClampingOn(); } +extern "C" void vtk_piecewise_function_clamping_off(vtkPiecewiseFunction* sself) { sself->ClampingOff(); } +extern "C" void vtk_piecewise_function_set_use_log_scale(vtkPiecewiseFunction* sself, bool _arg) { sself->SetUseLogScale(_arg); } +extern "C" bool vtk_piecewise_function_get_use_log_scale(vtkPiecewiseFunction* sself) { return sself->GetUseLogScale(); } +extern "C" void vtk_piecewise_function_use_log_scale_on(vtkPiecewiseFunction* sself) { sself->UseLogScaleOn(); } +extern "C" void vtk_piecewise_function_use_log_scale_off(vtkPiecewiseFunction* sself) { sself->UseLogScaleOff(); } +extern "C" const char* vtk_piecewise_function_get_type(vtkPiecewiseFunction* sself) { return sself->GetType(); } +extern "C" double vtk_piecewise_function_get_first_non_zero_value(vtkPiecewiseFunction* sself) { return sself->GetFirstNonZeroValue(); } +extern "C" void vtk_piecewise_function_initialize(vtkPiecewiseFunction* sself) { sself->Initialize(); } +extern "C" void vtk_piecewise_function_set_allow_duplicate_scalars(vtkPiecewiseFunction* sself, int _arg) { sself->SetAllowDuplicateScalars(_arg); } +extern "C" int vtk_piecewise_function_get_allow_duplicate_scalars(vtkPiecewiseFunction* sself) { return sself->GetAllowDuplicateScalars(); } +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_on(vtkPiecewiseFunction* sself) { sself->AllowDuplicateScalarsOn(); } +extern "C" void vtk_piecewise_function_allow_duplicate_scalars_off(vtkPiecewiseFunction* sself) { sself->AllowDuplicateScalarsOff(); } +extern "C" int vtk_piecewise_function_estimate_min_number_of_samples(vtkPiecewiseFunction* sself, const double& x1, const double& x2) { return sself->EstimateMinNumberOfSamples(x1, x2); } +extern "C" vtkPixel * vtkPixel_new () {return vtkPixel :: New () ;} +extern "C" void vtkPixel_destructor (vtkPixel * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_pixel_get_cell_type(vtkPixel* sself) { return sself->GetCellType(); } +extern "C" int vtk_pixel_get_cell_dimension(vtkPixel* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_pixel_get_number_of_edges(vtkPixel* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pixel_get_number_of_faces(vtkPixel* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_pixel_inflate(vtkPixel* sself, double dist) { return sself->Inflate(dist); } +extern "C" vtkPlane * vtkPlane_new () {return vtkPlane :: New () ;} +extern "C" void vtkPlane_destructor (vtkPlane * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_plane_set_normal(vtkPlane* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_plane_set_origin(vtkPlane* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_plane_push(vtkPlane* sself, double distance) { sself->Push(distance); } +extern "C" vtkPlaneCollection * vtkPlaneCollection_new () {return vtkPlaneCollection :: New () ;} +extern "C" void vtkPlaneCollection_destructor (vtkPlaneCollection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_plane_collection_get_number_of_items(vtkPlaneCollection* sself) { return sself->GetNumberOfItems(); } +extern "C" vtkPlanes * vtkPlanes_new () {return vtkPlanes :: New () ;} +extern "C" void vtkPlanes_destructor (vtkPlanes * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_planes_set_bounds(vtkPlanes* sself, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) { sself->SetBounds(xmin, xmax, ymin, ymax, zmin, zmax); } +extern "C" int vtk_planes_get_number_of_planes(vtkPlanes* sself) { return sself->GetNumberOfPlanes(); } +extern "C" vtkPlanesIntersection * vtkPlanesIntersection_new () {return vtkPlanesIntersection :: New () ;} +extern "C" void vtkPlanesIntersection_destructor (vtkPlanesIntersection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_planes_intersection_get_number_of_region_vertices(vtkPlanesIntersection* sself) { return sself->GetNumberOfRegionVertices(); } +extern "C" int vtk_planes_intersection_get_num_region_vertices(vtkPlanesIntersection* sself) { return sself->GetNumRegionVertices(); } +extern "C" vtkPointData * vtkPointData_new () {return vtkPointData :: New () ;} +extern "C" void vtkPointData_destructor (vtkPointData * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_point_data_null_point(vtkPointData* sself, long long ptId) { sself->NullPoint(ptId); } +extern "C" vtkPointLocator * vtkPointLocator_new () {return vtkPointLocator :: New () ;} +extern "C" void vtkPointLocator_destructor (vtkPointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_point_locator_set_divisions(vtkPointLocator* sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_point_locator_set_number_of_points_per_bucket(vtkPointLocator* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_min_value(vtkPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket_max_value(vtkPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_point_locator_get_number_of_points_per_bucket(vtkPointLocator* sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" long long vtk_point_locator_is_inserted_point(vtkPointLocator* sself, double x, double y, double z) { return sself->IsInsertedPoint(x, y, z); } +extern "C" void vtk_point_locator_initialize(vtkPointLocator* sself) { sself->Initialize(); } +extern "C" void vtk_point_locator_free_search_structure(vtkPointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_point_locator_build_locator(vtkPointLocator* sself) { sself->BuildLocator(); } +extern "C" vtkPointSet * vtkPointSet_new () {return vtkPointSet :: New () ;} +extern "C" void vtkPointSet_destructor (vtkPointSet * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_point_set_set_editable(vtkPointSet* sself, bool _arg) { sself->SetEditable(_arg); } +extern "C" bool vtk_point_set_get_editable(vtkPointSet* sself) { return sself->GetEditable(); } +extern "C" void vtk_point_set_editable_on(vtkPointSet* sself) { sself->EditableOn(); } +extern "C" void vtk_point_set_editable_off(vtkPointSet* sself) { sself->EditableOff(); } +extern "C" void vtk_point_set_initialize(vtkPointSet* sself) { sself->Initialize(); } +extern "C" long long vtk_point_set_get_number_of_points(vtkPointSet* sself) { return sself->GetNumberOfPoints(); } +extern "C" long long vtk_point_set_get_number_of_cells(vtkPointSet* sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_point_set_get_max_cell_size(vtkPointSet* sself) { return sself->GetMaxCellSize(); } +extern "C" int vtk_point_set_get_cell_type(vtkPointSet* sself, long long p0) { return sself->GetCellType(p0); } +extern "C" void vtk_point_set_build_point_locator(vtkPointSet* sself) { sself->BuildPointLocator(); } +extern "C" void vtk_point_set_build_locator(vtkPointSet* sself) { sself->BuildLocator(); } +extern "C" void vtk_point_set_build_cell_locator(vtkPointSet* sself) { sself->BuildCellLocator(); } +extern "C" unsigned long vtk_point_set_get_m_time(vtkPointSet* sself) { return sself->GetMTime(); } +extern "C" void vtk_point_set_compute_bounds(vtkPointSet* sself) { sself->ComputeBounds(); } +extern "C" void vtk_point_set_squeeze(vtkPointSet* sself) { sself->Squeeze(); } +extern "C" vtkPointSetCellIterator * vtkPointSetCellIterator_new () {return vtkPointSetCellIterator :: New () ;} +extern "C" void vtkPointSetCellIterator_destructor (vtkPointSetCellIterator * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_point_set_cell_iterator_is_done_with_traversal(vtkPointSetCellIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_point_set_cell_iterator_get_cell_id(vtkPointSetCellIterator* sself) { return sself->GetCellId(); } +extern "C" vtkPointsProjectedHull * vtkPointsProjectedHull_new () {return vtkPointsProjectedHull :: New () ;} +extern "C" void vtkPointsProjectedHull_destructor (vtkPointsProjectedHull * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_x(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullX(); } +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_y(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullY(); } +extern "C" int vtk_points_projected_hull_get_size_ccw_hull_z(vtkPointsProjectedHull* sself) { return sself->GetSizeCCWHullZ(); } +extern "C" void vtk_points_projected_hull_update(vtkPointsProjectedHull* sself) { sself->Update(); } +extern "C" vtkPolyData * vtkPolyData_new () {return vtkPolyData :: New () ;} +extern "C" void vtkPolyData_destructor (vtkPolyData * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_poly_data_get_data_object_type(vtkPolyData* sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_poly_data_get_number_of_cells(vtkPolyData* sself) { return sself->GetNumberOfCells(); } +extern "C" int vtk_poly_data_get_cell_type(vtkPolyData* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_poly_data_compute_cells_bounds(vtkPolyData* sself) { sself->ComputeCellsBounds(); } +extern "C" void vtk_poly_data_squeeze(vtkPolyData* sself) { sself->Squeeze(); } +extern "C" int vtk_poly_data_get_max_cell_size(vtkPolyData* sself) { return sself->GetMaxCellSize(); } +extern "C" long long vtk_poly_data_get_cell_id_relative_to_cell_array(vtkPolyData* sself, long long cellId) { return sself->GetCellIdRelativeToCellArray(cellId); } +extern "C" long long vtk_poly_data_get_number_of_verts(vtkPolyData* sself) { return sself->GetNumberOfVerts(); } +extern "C" long long vtk_poly_data_get_number_of_lines(vtkPolyData* sself) { return sself->GetNumberOfLines(); } +extern "C" long long vtk_poly_data_get_number_of_polys(vtkPolyData* sself) { return sself->GetNumberOfPolys(); } +extern "C" long long vtk_poly_data_get_number_of_strips(vtkPolyData* sself) { return sself->GetNumberOfStrips(); } +extern "C" bool vtk_poly_data_allocate_estimate(vtkPolyData* sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_poly_data_allocate_exact(vtkPolyData* sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" void vtk_poly_data_allocate(vtkPolyData* sself, long long numCells, int extSize) { sself->Allocate(numCells, extSize); } +extern "C" void vtk_poly_data_reset(vtkPolyData* sself) { sself->Reset(); } +extern "C" void vtk_poly_data_build_cells(vtkPolyData* sself) { sself->BuildCells(); } +extern "C" bool vtk_poly_data_need_to_build_cells(vtkPolyData* sself) { return sself->NeedToBuildCells(); } +extern "C" void vtk_poly_data_build_links(vtkPolyData* sself, int initialSize) { sself->BuildLinks(initialSize); } +extern "C" void vtk_poly_data_delete_cells(vtkPolyData* sself) { sself->DeleteCells(); } +extern "C" void vtk_poly_data_delete_links(vtkPolyData* sself) { sself->DeleteLinks(); } +extern "C" int vtk_poly_data_is_triangle(vtkPolyData* sself, int v1, int v2, int v3) { return sself->IsTriangle(v1, v2, v3); } +extern "C" int vtk_poly_data_is_edge(vtkPolyData* sself, long long p1, long long p2) { return sself->IsEdge(p1, p2); } +extern "C" int vtk_poly_data_is_point_used_by_cell(vtkPolyData* sself, long long ptId, long long cellId) { return sself->IsPointUsedByCell(ptId, cellId); } +extern "C" void vtk_poly_data_replace_cell_point(vtkPolyData* sself, long long cellId, long long oldPtId, long long newPtId) { sself->ReplaceCellPoint(cellId, oldPtId, newPtId); } +extern "C" void vtk_poly_data_reverse_cell(vtkPolyData* sself, long long cellId) { sself->ReverseCell(cellId); } +extern "C" void vtk_poly_data_delete_point(vtkPolyData* sself, long long ptId) { sself->DeletePoint(ptId); } +extern "C" void vtk_poly_data_delete_cell(vtkPolyData* sself, long long cellId) { sself->DeleteCell(cellId); } +extern "C" void vtk_poly_data_remove_deleted_cells(vtkPolyData* sself) { sself->RemoveDeletedCells(); } +extern "C" long long vtk_poly_data_insert_next_linked_point(vtkPolyData* sself, int numLinks) { return sself->InsertNextLinkedPoint(numLinks); } +extern "C" void vtk_poly_data_remove_cell_reference(vtkPolyData* sself, long long cellId) { sself->RemoveCellReference(cellId); } +extern "C" void vtk_poly_data_add_cell_reference(vtkPolyData* sself, long long cellId) { sself->AddCellReference(cellId); } +extern "C" void vtk_poly_data_remove_reference_to_cell(vtkPolyData* sself, long long ptId, long long cellId) { sself->RemoveReferenceToCell(ptId, cellId); } +extern "C" void vtk_poly_data_add_reference_to_cell(vtkPolyData* sself, long long ptId, long long cellId) { sself->AddReferenceToCell(ptId, cellId); } +extern "C" void vtk_poly_data_resize_cell_list(vtkPolyData* sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" void vtk_poly_data_initialize(vtkPolyData* sself) { sself->Initialize(); } +extern "C" int vtk_poly_data_get_piece(vtkPolyData* sself) { return sself->GetPiece(); } +extern "C" int vtk_poly_data_get_number_of_pieces(vtkPolyData* sself) { return sself->GetNumberOfPieces(); } +extern "C" int vtk_poly_data_get_ghost_level(vtkPolyData* sself) { return sself->GetGhostLevel(); } +extern "C" void vtk_poly_data_remove_ghost_cells(vtkPolyData* sself) { sself->RemoveGhostCells(); } +extern "C" unsigned long vtk_poly_data_get_mesh_m_time(vtkPolyData* sself) { return sself->GetMeshMTime(); } +extern "C" unsigned long vtk_poly_data_get_m_time(vtkPolyData* sself) { return sself->GetMTime(); } +extern "C" vtkPolyDataCollection * vtkPolyDataCollection_new () {return vtkPolyDataCollection :: New () ;} +extern "C" void vtkPolyDataCollection_destructor (vtkPolyDataCollection * sself) {sself -> Delete () ; return ;} +extern "C" vtkPolyLine * vtkPolyLine_new () {return vtkPolyLine :: New () ;} +extern "C" void vtkPolyLine_destructor (vtkPolyLine * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_poly_line_get_cell_type(vtkPolyLine* sself) { return sself->GetCellType(); } +extern "C" int vtk_poly_line_get_cell_dimension(vtkPolyLine* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_poly_line_get_number_of_edges(vtkPolyLine* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_poly_line_get_number_of_faces(vtkPolyLine* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkPolyPlane * vtkPolyPlane_new () {return vtkPolyPlane :: New () ;} +extern "C" void vtkPolyPlane_destructor (vtkPolyPlane * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_poly_plane_get_m_time(vtkPolyPlane* sself) { return sself->GetMTime(); } +extern "C" vtkPolyVertex * vtkPolyVertex_new () {return vtkPolyVertex :: New () ;} +extern "C" void vtkPolyVertex_destructor (vtkPolyVertex * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_poly_vertex_get_cell_type(vtkPolyVertex* sself) { return sself->GetCellType(); } +extern "C" int vtk_poly_vertex_get_cell_dimension(vtkPolyVertex* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_poly_vertex_get_number_of_edges(vtkPolyVertex* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_poly_vertex_get_number_of_faces(vtkPolyVertex* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkPolygon * vtkPolygon_new () {return vtkPolygon :: New () ;} +extern "C" void vtkPolygon_destructor (vtkPolygon * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_polygon_get_cell_type(vtkPolygon* sself) { return sself->GetCellType(); } +extern "C" int vtk_polygon_get_cell_dimension(vtkPolygon* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_polygon_get_number_of_edges(vtkPolygon* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_polygon_get_number_of_faces(vtkPolygon* sself) { return sself->GetNumberOfFaces(); } +extern "C" double vtk_polygon_compute_area(vtkPolygon* sself) { return sself->ComputeArea(); } +extern "C" bool vtk_polygon_is_convex(vtkPolygon* sself) { return sself->IsConvex(); } +extern "C" bool vtk_polygon_get_use_mvc_interpolation(vtkPolygon* sself) { return sself->GetUseMVCInterpolation(); } +extern "C" void vtk_polygon_set_use_mvc_interpolation(vtkPolygon* sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } +extern "C" void vtk_polygon_set_tolerance(vtkPolygon* sself, double _arg) { sself->SetTolerance(_arg); } +extern "C" double vtk_polygon_get_tolerance_min_value(vtkPolygon* sself) { return sself->GetToleranceMinValue(); } +extern "C" double vtk_polygon_get_tolerance_max_value(vtkPolygon* sself) { return sself->GetToleranceMaxValue(); } +extern "C" double vtk_polygon_get_tolerance(vtkPolygon* sself) { return sself->GetTolerance(); } +extern "C" int vtk_polygon_ear_cut_triangulation(vtkPolygon* sself, int measure) { return sself->EarCutTriangulation(measure); } +extern "C" int vtk_polygon_unbiased_ear_cut_triangulation(vtkPolygon* sself, int seed, int measure) { return sself->UnbiasedEarCutTriangulation(seed, measure); } +extern "C" vtkPolyhedron * vtkPolyhedron_new () {return vtkPolyhedron :: New () ;} +extern "C" void vtkPolyhedron_destructor (vtkPolyhedron * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_polyhedron_get_cell_type(vtkPolyhedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_polyhedron_requires_initialization(vtkPolyhedron* sself) { return sself->RequiresInitialization(); } +extern "C" int vtk_polyhedron_get_number_of_edges(vtkPolyhedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_polyhedron_get_number_of_faces(vtkPolyhedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_polyhedron_is_primary_cell(vtkPolyhedron* sself) { return sself->IsPrimaryCell(); } +extern "C" int vtk_polyhedron_requires_explicit_face_representation(vtkPolyhedron* sself) { return sself->RequiresExplicitFaceRepresentation(); } +extern "C" bool vtk_polyhedron_is_convex(vtkPolyhedron* sself) { return sself->IsConvex(); } +extern "C" vtkPyramid * vtkPyramid_new () {return vtkPyramid :: New () ;} +extern "C" void vtkPyramid_destructor (vtkPyramid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_pyramid_get_cell_type(vtkPyramid* sself) { return sself->GetCellType(); } +extern "C" int vtk_pyramid_get_number_of_edges(vtkPyramid* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_pyramid_get_number_of_faces(vtkPyramid* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuad * vtkQuad_new () {return vtkQuad :: New () ;} +extern "C" void vtkQuad_destructor (vtkQuad * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quad_get_cell_type(vtkQuad* sself) { return sself->GetCellType(); } +extern "C" int vtk_quad_get_cell_dimension(vtkQuad* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quad_get_number_of_edges(vtkQuad* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quad_get_number_of_faces(vtkQuad* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticEdge * vtkQuadraticEdge_new () {return vtkQuadraticEdge :: New () ;} +extern "C" void vtkQuadraticEdge_destructor (vtkQuadraticEdge * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_edge_get_cell_type(vtkQuadraticEdge* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_edge_get_cell_dimension(vtkQuadraticEdge* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_edge_get_number_of_edges(vtkQuadraticEdge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_edge_get_number_of_faces(vtkQuadraticEdge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticHexahedron * vtkQuadraticHexahedron_new () {return vtkQuadraticHexahedron :: New () ;} +extern "C" void vtkQuadraticHexahedron_destructor (vtkQuadraticHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_hexahedron_get_cell_type(vtkQuadraticHexahedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_hexahedron_get_cell_dimension(vtkQuadraticHexahedron* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_hexahedron_get_number_of_edges(vtkQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_hexahedron_get_number_of_faces(vtkQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticLinearQuad * vtkQuadraticLinearQuad_new () {return vtkQuadraticLinearQuad :: New () ;} +extern "C" void vtkQuadraticLinearQuad_destructor (vtkQuadraticLinearQuad * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_linear_quad_get_cell_type(vtkQuadraticLinearQuad* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_linear_quad_get_cell_dimension(vtkQuadraticLinearQuad* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_linear_quad_get_number_of_edges(vtkQuadraticLinearQuad* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_linear_quad_get_number_of_faces(vtkQuadraticLinearQuad* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticLinearWedge * vtkQuadraticLinearWedge_new () {return vtkQuadraticLinearWedge :: New () ;} +extern "C" void vtkQuadraticLinearWedge_destructor (vtkQuadraticLinearWedge * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_linear_wedge_get_cell_type(vtkQuadraticLinearWedge* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_linear_wedge_get_cell_dimension(vtkQuadraticLinearWedge* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_linear_wedge_get_number_of_edges(vtkQuadraticLinearWedge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_linear_wedge_get_number_of_faces(vtkQuadraticLinearWedge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticPolygon * vtkQuadraticPolygon_new () {return vtkQuadraticPolygon :: New () ;} +extern "C" void vtkQuadraticPolygon_destructor (vtkQuadraticPolygon * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_polygon_get_cell_type(vtkQuadraticPolygon* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_polygon_get_cell_dimension(vtkQuadraticPolygon* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_polygon_get_number_of_edges(vtkQuadraticPolygon* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_polygon_get_number_of_faces(vtkQuadraticPolygon* sself) { return sself->GetNumberOfFaces(); } +extern "C" bool vtk_quadratic_polygon_get_use_mvc_interpolation(vtkQuadraticPolygon* sself) { return sself->GetUseMVCInterpolation(); } +extern "C" void vtk_quadratic_polygon_set_use_mvc_interpolation(vtkQuadraticPolygon* sself, bool _arg) { sself->SetUseMVCInterpolation(_arg); } +extern "C" vtkQuadraticPyramid * vtkQuadraticPyramid_new () {return vtkQuadraticPyramid :: New () ;} +extern "C" void vtkQuadraticPyramid_destructor (vtkQuadraticPyramid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_pyramid_get_cell_type(vtkQuadraticPyramid* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_pyramid_get_cell_dimension(vtkQuadraticPyramid* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_pyramid_get_number_of_edges(vtkQuadraticPyramid* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_pyramid_get_number_of_faces(vtkQuadraticPyramid* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticQuad * vtkQuadraticQuad_new () {return vtkQuadraticQuad :: New () ;} +extern "C" void vtkQuadraticQuad_destructor (vtkQuadraticQuad * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_quad_get_cell_type(vtkQuadraticQuad* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_quad_get_cell_dimension(vtkQuadraticQuad* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_quad_get_number_of_edges(vtkQuadraticQuad* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_quad_get_number_of_faces(vtkQuadraticQuad* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticTetra * vtkQuadraticTetra_new () {return vtkQuadraticTetra :: New () ;} +extern "C" void vtkQuadraticTetra_destructor (vtkQuadraticTetra * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_tetra_get_cell_type(vtkQuadraticTetra* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_tetra_get_cell_dimension(vtkQuadraticTetra* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_tetra_get_number_of_edges(vtkQuadraticTetra* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_tetra_get_number_of_faces(vtkQuadraticTetra* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticTriangle * vtkQuadraticTriangle_new () {return vtkQuadraticTriangle :: New () ;} +extern "C" void vtkQuadraticTriangle_destructor (vtkQuadraticTriangle * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_triangle_get_cell_type(vtkQuadraticTriangle* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_triangle_get_cell_dimension(vtkQuadraticTriangle* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_triangle_get_number_of_edges(vtkQuadraticTriangle* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_triangle_get_number_of_faces(vtkQuadraticTriangle* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadraticWedge * vtkQuadraticWedge_new () {return vtkQuadraticWedge :: New () ;} +extern "C" void vtkQuadraticWedge_destructor (vtkQuadraticWedge * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quadratic_wedge_get_cell_type(vtkQuadraticWedge* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadratic_wedge_get_cell_dimension(vtkQuadraticWedge* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_quadratic_wedge_get_number_of_edges(vtkQuadraticWedge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_quadratic_wedge_get_number_of_faces(vtkQuadraticWedge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkQuadratureSchemeDefinition * vtkQuadratureSchemeDefinition_new () {return vtkQuadratureSchemeDefinition :: New () ;} +extern "C" void vtkQuadratureSchemeDefinition_destructor (vtkQuadratureSchemeDefinition * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_quadrature_scheme_definition_clear(vtkQuadratureSchemeDefinition* sself) { sself->Clear(); } +extern "C" int vtk_quadrature_scheme_definition_get_cell_type(vtkQuadratureSchemeDefinition* sself) { return sself->GetCellType(); } +extern "C" int vtk_quadrature_scheme_definition_get_quadrature_key(vtkQuadratureSchemeDefinition* sself) { return sself->GetQuadratureKey(); } +extern "C" int vtk_quadrature_scheme_definition_get_number_of_nodes(vtkQuadratureSchemeDefinition* sself) { return sself->GetNumberOfNodes(); } +extern "C" int vtk_quadrature_scheme_definition_get_number_of_quadrature_points(vtkQuadratureSchemeDefinition* sself) { return sself->GetNumberOfQuadraturePoints(); } +extern "C" vtkQuadric * vtkQuadric_new () {return vtkQuadric :: New () ;} +extern "C" void vtkQuadric_destructor (vtkQuadric * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_quadric_set_coefficients(vtkQuadric* sself, double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9) { sself->SetCoefficients(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } +extern "C" vtkRectilinearGrid * vtkRectilinearGrid_new () {return vtkRectilinearGrid :: New () ;} +extern "C" void vtkRectilinearGrid_destructor (vtkRectilinearGrid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_rectilinear_grid_get_data_object_type(vtkRectilinearGrid* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_rectilinear_grid_initialize(vtkRectilinearGrid* sself) { sself->Initialize(); } +extern "C" long long vtk_rectilinear_grid_get_number_of_cells(vtkRectilinearGrid* sself) { return sself->GetNumberOfCells(); } +extern "C" long long vtk_rectilinear_grid_get_number_of_points(vtkRectilinearGrid* sself) { return sself->GetNumberOfPoints(); } +extern "C" int vtk_rectilinear_grid_get_cell_type(vtkRectilinearGrid* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" int vtk_rectilinear_grid_get_max_cell_size(vtkRectilinearGrid* sself) { return sself->GetMaxCellSize(); } +extern "C" unsigned char vtk_rectilinear_grid_is_point_visible(vtkRectilinearGrid* sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_rectilinear_grid_is_cell_visible(vtkRectilinearGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_rectilinear_grid_has_any_blank_points(vtkRectilinearGrid* sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_rectilinear_grid_has_any_blank_cells(vtkRectilinearGrid* sself) { return sself->HasAnyBlankCells(); } +extern "C" void vtk_rectilinear_grid_set_dimensions(vtkRectilinearGrid* sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" int vtk_rectilinear_grid_get_data_dimension(vtkRectilinearGrid* sself) { return sself->GetDataDimension(); } +extern "C" void vtk_rectilinear_grid_set_extent(vtkRectilinearGrid* sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax) { sself->SetExtent(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" int vtk_rectilinear_grid_get_extent_type(vtkRectilinearGrid* sself) { return sself->GetExtentType(); } +extern "C" const char* vtk_rectilinear_grid_get_scalar_type_as_string(vtkRectilinearGrid* sself) { return sself->GetScalarTypeAsString(); } +extern "C" vtkReebGraph * vtkReebGraph_new () {return vtkReebGraph :: New () ;} +extern "C" void vtkReebGraph_destructor (vtkReebGraph * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_reeb_graph_stream_triangle(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2) { return sself->StreamTriangle(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2); } +extern "C" int vtk_reeb_graph_stream_tetrahedron(vtkReebGraph* sself, long long vertex0Id, double scalar0, long long vertex1Id, double scalar1, long long vertex2Id, double scalar2, long long vertex3Id, double scalar3) { return sself->StreamTetrahedron(vertex0Id, scalar0, vertex1Id, scalar1, vertex2Id, scalar2, vertex3Id, scalar3); } +extern "C" void vtk_reeb_graph_close_stream(vtkReebGraph* sself) { sself->CloseStream(); } +extern "C" vtkReebGraphSimplificationMetric * vtkReebGraphSimplificationMetric_new () {return vtkReebGraphSimplificationMetric :: New () ;} +extern "C" void vtkReebGraphSimplificationMetric_destructor (vtkReebGraphSimplificationMetric * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_reeb_graph_simplification_metric_set_lower_bound(vtkReebGraphSimplificationMetric* sself, double _arg) { sself->SetLowerBound(_arg); } +extern "C" double vtk_reeb_graph_simplification_metric_get_lower_bound(vtkReebGraphSimplificationMetric* sself) { return sself->GetLowerBound(); } +extern "C" void vtk_reeb_graph_simplification_metric_set_upper_bound(vtkReebGraphSimplificationMetric* sself, double _arg) { sself->SetUpperBound(_arg); } +extern "C" double vtk_reeb_graph_simplification_metric_get_upper_bound(vtkReebGraphSimplificationMetric* sself) { return sself->GetUpperBound(); } +extern "C" vtkSelection * vtkSelection_new () {return vtkSelection :: New () ;} +extern "C" void vtkSelection_destructor (vtkSelection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_selection_get_data_object_type(vtkSelection* sself) { return sself->GetDataObjectType(); } +extern "C" unsigned int vtk_selection_get_number_of_nodes(vtkSelection* sself) { return sself->GetNumberOfNodes(); } +extern "C" void vtk_selection_remove_node(vtkSelection* sself, unsigned int idx) { sself->RemoveNode(idx); } +extern "C" void vtk_selection_remove_all_nodes(vtkSelection* sself) { sself->RemoveAllNodes(); } +extern "C" void vtk_selection_set_expression(vtkSelection* sself, const char* _arg) { sself->SetExpression(_arg); } +extern "C" unsigned long vtk_selection_get_m_time(vtkSelection* sself) { return sself->GetMTime(); } +extern "C" void vtk_selection_dump(vtkSelection* sself) { sself->Dump(); } +extern "C" vtkSelectionNode * vtkSelectionNode_new () {return vtkSelectionNode :: New () ;} +extern "C" void vtkSelectionNode_destructor (vtkSelectionNode * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_selection_node_initialize(vtkSelectionNode* sself) { sself->Initialize(); } +extern "C" unsigned long vtk_selection_node_get_m_time(vtkSelectionNode* sself) { return sself->GetMTime(); } +extern "C" void vtk_selection_node_set_content_type(vtkSelectionNode* sself, int type) { sself->SetContentType(type); } +extern "C" int vtk_selection_node_get_content_type(vtkSelectionNode* sself) { return sself->GetContentType(); } +extern "C" const char* vtk_selection_node_get_content_type_as_string(vtkSelectionNode* sself, int type) { return sself->GetContentTypeAsString(type); } +extern "C" void vtk_selection_node_set_field_type(vtkSelectionNode* sself, int type) { sself->SetFieldType(type); } +extern "C" int vtk_selection_node_get_field_type(vtkSelectionNode* sself) { return sself->GetFieldType(); } +extern "C" const char* vtk_selection_node_get_field_type_as_string(vtkSelectionNode* sself, int type) { return sself->GetFieldTypeAsString(type); } +extern "C" int vtk_selection_node_get_field_type_from_string(vtkSelectionNode* sself, const char* type) { return sself->GetFieldTypeFromString(type); } +extern "C" int vtk_selection_node_convert_selection_field_to_attribute_type(vtkSelectionNode* sself, int val) { return sself->ConvertSelectionFieldToAttributeType(val); } +extern "C" int vtk_selection_node_convert_attribute_type_to_selection_field(vtkSelectionNode* sself, int val) { return sself->ConvertAttributeTypeToSelectionField(val); } +extern "C" void vtk_selection_node_set_query_string(vtkSelectionNode* sself, const char* _arg) { sself->SetQueryString(_arg); } +extern "C" vtkSimpleCellTessellator * vtkSimpleCellTessellator_new () {return vtkSimpleCellTessellator :: New () ;} +extern "C" void vtkSimpleCellTessellator_destructor (vtkSimpleCellTessellator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_simple_cell_tessellator_reset(vtkSimpleCellTessellator* sself) { sself->Reset(); } +extern "C" int vtk_simple_cell_tessellator_get_fixed_subdivisions(vtkSimpleCellTessellator* sself) { return sself->GetFixedSubdivisions(); } +extern "C" int vtk_simple_cell_tessellator_get_max_subdivision_level(vtkSimpleCellTessellator* sself) { return sself->GetMaxSubdivisionLevel(); } +extern "C" int vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(vtkSimpleCellTessellator* sself) { return sself->GetMaxAdaptiveSubdivisions(); } +extern "C" void vtk_simple_cell_tessellator_set_fixed_subdivisions(vtkSimpleCellTessellator* sself, int level) { sself->SetFixedSubdivisions(level); } +extern "C" void vtk_simple_cell_tessellator_set_max_subdivision_level(vtkSimpleCellTessellator* sself, int level) { sself->SetMaxSubdivisionLevel(level); } +extern "C" void vtk_simple_cell_tessellator_set_subdivision_levels(vtkSimpleCellTessellator* sself, int fixed, int maxLevel) { sself->SetSubdivisionLevels(fixed, maxLevel); } +extern "C" vtkSmoothErrorMetric * vtkSmoothErrorMetric_new () {return vtkSmoothErrorMetric :: New () ;} +extern "C" void vtkSmoothErrorMetric_destructor (vtkSmoothErrorMetric * sself) {sself -> Delete () ; return ;} +extern "C" double vtk_smooth_error_metric_get_angle_tolerance(vtkSmoothErrorMetric* sself) { return sself->GetAngleTolerance(); } +extern "C" void vtk_smooth_error_metric_set_angle_tolerance(vtkSmoothErrorMetric* sself, double value) { sself->SetAngleTolerance(value); } +extern "C" vtkSortFieldData * vtkSortFieldData_new () {return vtkSortFieldData :: New () ;} +extern "C" void vtkSortFieldData_destructor (vtkSortFieldData * sself) {sself -> Delete () ; return ;} +extern "C" vtkSphere * vtkSphere_new () {return vtkSphere :: New () ;} +extern "C" void vtkSphere_destructor (vtkSphere * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_sphere_set_radius(vtkSphere* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_sphere_get_radius(vtkSphere* sself) { return sself->GetRadius(); } +extern "C" void vtk_sphere_set_center(vtkSphere* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" vtkSpheres * vtkSpheres_new () {return vtkSpheres :: New () ;} +extern "C" void vtkSpheres_destructor (vtkSpheres * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_spheres_get_number_of_spheres(vtkSpheres* sself) { return sself->GetNumberOfSpheres(); } +extern "C" vtkStaticCellLinks * vtkStaticCellLinks_new () {return vtkStaticCellLinks :: New () ;} +extern "C" void vtkStaticCellLinks_destructor (vtkStaticCellLinks * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_static_cell_links_get_number_of_cells(vtkStaticCellLinks* sself, long long ptId) { return sself->GetNumberOfCells(ptId); } +extern "C" long long vtk_static_cell_links_get_ncells(vtkStaticCellLinks* sself, long long ptId) { return sself->GetNcells(ptId); } +extern "C" void vtk_static_cell_links_initialize(vtkStaticCellLinks* sself) { sself->Initialize(); } +extern "C" void vtk_static_cell_links_squeeze(vtkStaticCellLinks* sself) { sself->Squeeze(); } +extern "C" void vtk_static_cell_links_reset(vtkStaticCellLinks* sself) { sself->Reset(); } +extern "C" unsigned long vtk_static_cell_links_get_actual_memory_size(vtkStaticCellLinks* sself) { return sself->GetActualMemorySize(); } +extern "C" vtkStaticCellLocator * vtkStaticCellLocator_new () {return vtkStaticCellLocator :: New () ;} +extern "C" void vtkStaticCellLocator_destructor (vtkStaticCellLocator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_static_cell_locator_set_divisions(vtkStaticCellLocator* sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_static_cell_locator_free_search_structure(vtkStaticCellLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_cell_locator_build_locator(vtkStaticCellLocator* sself) { sself->BuildLocator(); } +extern "C" void vtk_static_cell_locator_set_max_number_of_buckets(vtkStaticCellLocator* sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_min_value(vtkStaticCellLocator* sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets_max_value(vtkStaticCellLocator* sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_cell_locator_get_max_number_of_buckets(vtkStaticCellLocator* sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_cell_locator_get_large_ids(vtkStaticCellLocator* sself) { return sself->GetLargeIds(); } +extern "C" void vtk_static_cell_locator_set_use_diagonal_length_tolerance(vtkStaticCellLocator* sself, bool _arg) { sself->SetUseDiagonalLengthTolerance(_arg); } +extern "C" bool vtk_static_cell_locator_get_use_diagonal_length_tolerance(vtkStaticCellLocator* sself) { return sself->GetUseDiagonalLengthTolerance(); } +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_on(vtkStaticCellLocator* sself) { sself->UseDiagonalLengthToleranceOn(); } +extern "C" void vtk_static_cell_locator_use_diagonal_length_tolerance_off(vtkStaticCellLocator* sself) { sself->UseDiagonalLengthToleranceOff(); } +extern "C" vtkStaticPointLocator * vtkStaticPointLocator_new () {return vtkStaticPointLocator :: New () ;} +extern "C" void vtkStaticPointLocator_destructor (vtkStaticPointLocator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_static_point_locator_set_number_of_points_per_bucket(vtkStaticPointLocator* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator* sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_static_point_locator_get_number_of_points_per_bucket(vtkStaticPointLocator* sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" void vtk_static_point_locator_set_divisions(vtkStaticPointLocator* sself, int _arg1, int _arg2, int _arg3) { sself->SetDivisions(_arg1, _arg2, _arg3); } +extern "C" void vtk_static_point_locator_initialize(vtkStaticPointLocator* sself) { sself->Initialize(); } +extern "C" void vtk_static_point_locator_free_search_structure(vtkStaticPointLocator* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_point_locator_build_locator(vtkStaticPointLocator* sself) { sself->BuildLocator(); } +extern "C" long long vtk_static_point_locator_get_number_of_points_in_bucket(vtkStaticPointLocator* sself, long long bNum) { return sself->GetNumberOfPointsInBucket(bNum); } +extern "C" void vtk_static_point_locator_set_max_number_of_buckets(vtkStaticPointLocator* sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_min_value(vtkStaticPointLocator* sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets_max_value(vtkStaticPointLocator* sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_point_locator_get_max_number_of_buckets(vtkStaticPointLocator* sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_point_locator_get_large_ids(vtkStaticPointLocator* sself) { return sself->GetLargeIds(); } +extern "C" vtkStaticPointLocator2D * vtkStaticPointLocator2D_new () {return vtkStaticPointLocator2D :: New () ;} +extern "C" void vtkStaticPointLocator2D_destructor (vtkStaticPointLocator2D * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_static_point_locator_2_d_set_number_of_points_per_bucket(vtkStaticPointLocator2D* sself, int _arg) { sself->SetNumberOfPointsPerBucket(_arg); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value(vtkStaticPointLocator2D* sself) { return sself->GetNumberOfPointsPerBucketMinValue(); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value(vtkStaticPointLocator2D* sself) { return sself->GetNumberOfPointsPerBucketMaxValue(); } +extern "C" int vtk_static_point_locator_2_d_get_number_of_points_per_bucket(vtkStaticPointLocator2D* sself) { return sself->GetNumberOfPointsPerBucket(); } +extern "C" void vtk_static_point_locator_2_d_set_divisions(vtkStaticPointLocator2D* sself, int _arg1, int _arg2) { sself->SetDivisions(_arg1, _arg2); } +extern "C" void vtk_static_point_locator_2_d_initialize(vtkStaticPointLocator2D* sself) { sself->Initialize(); } +extern "C" void vtk_static_point_locator_2_d_free_search_structure(vtkStaticPointLocator2D* sself) { sself->FreeSearchStructure(); } +extern "C" void vtk_static_point_locator_2_d_build_locator(vtkStaticPointLocator2D* sself) { sself->BuildLocator(); } +extern "C" long long vtk_static_point_locator_2_d_get_number_of_points_in_bucket(vtkStaticPointLocator2D* sself, long long bNum) { return sself->GetNumberOfPointsInBucket(bNum); } +extern "C" void vtk_static_point_locator_2_d_set_max_number_of_buckets(vtkStaticPointLocator2D* sself, long long _arg) { sself->SetMaxNumberOfBuckets(_arg); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(vtkStaticPointLocator2D* sself) { return sself->GetMaxNumberOfBucketsMinValue(); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(vtkStaticPointLocator2D* sself) { return sself->GetMaxNumberOfBucketsMaxValue(); } +extern "C" long long vtk_static_point_locator_2_d_get_max_number_of_buckets(vtkStaticPointLocator2D* sself) { return sself->GetMaxNumberOfBuckets(); } +extern "C" bool vtk_static_point_locator_2_d_get_large_ids(vtkStaticPointLocator2D* sself) { return sself->GetLargeIds(); } +extern "C" vtkStructuredExtent * vtkStructuredExtent_new () {return vtkStructuredExtent :: New () ;} +extern "C" void vtkStructuredExtent_destructor (vtkStructuredExtent * sself) {sself -> Delete () ; return ;} +extern "C" vtkStructuredGrid * vtkStructuredGrid_new () {return vtkStructuredGrid :: New () ;} +extern "C" void vtkStructuredGrid_destructor (vtkStructuredGrid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_structured_grid_get_data_object_type(vtkStructuredGrid* sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_structured_grid_get_number_of_points(vtkStructuredGrid* sself) { return sself->GetNumberOfPoints(); } +extern "C" int vtk_structured_grid_get_cell_type(vtkStructuredGrid* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_structured_grid_set_dimensions(vtkStructuredGrid* sself, int i, int j, int k) { sself->SetDimensions(i, j, k); } +extern "C" int vtk_structured_grid_get_data_dimension(vtkStructuredGrid* sself) { return sself->GetDataDimension(); } +extern "C" void vtk_structured_grid_set_extent(vtkStructuredGrid* sself, int xMin, int xMax, int yMin, int yMax, int zMin, int zMax) { sself->SetExtent(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" int vtk_structured_grid_get_extent_type(vtkStructuredGrid* sself) { return sself->GetExtentType(); } +extern "C" void vtk_structured_grid_blank_point(vtkStructuredGrid* sself, long long ptId) { sself->BlankPoint(ptId); } +extern "C" void vtk_structured_grid_un_blank_point(vtkStructuredGrid* sself, long long ptId) { sself->UnBlankPoint(ptId); } +extern "C" void vtk_structured_grid_blank_cell(vtkStructuredGrid* sself, long long ptId) { sself->BlankCell(ptId); } +extern "C" void vtk_structured_grid_un_blank_cell(vtkStructuredGrid* sself, long long ptId) { sself->UnBlankCell(ptId); } +extern "C" unsigned char vtk_structured_grid_is_point_visible(vtkStructuredGrid* sself, long long ptId) { return sself->IsPointVisible(ptId); } +extern "C" unsigned char vtk_structured_grid_is_cell_visible(vtkStructuredGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" bool vtk_structured_grid_has_any_blank_points(vtkStructuredGrid* sself) { return sself->HasAnyBlankPoints(); } +extern "C" bool vtk_structured_grid_has_any_blank_cells(vtkStructuredGrid* sself) { return sself->HasAnyBlankCells(); } +extern "C" vtkStructuredPoints * vtkStructuredPoints_new () {return vtkStructuredPoints :: New () ;} +extern "C" void vtkStructuredPoints_destructor (vtkStructuredPoints * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_structured_points_get_data_object_type(vtkStructuredPoints* sself) { return sself->GetDataObjectType(); } +extern "C" vtkStructuredPointsCollection * vtkStructuredPointsCollection_new () {return vtkStructuredPointsCollection :: New () ;} +extern "C" void vtkStructuredPointsCollection_destructor (vtkStructuredPointsCollection * sself) {sself -> Delete () ; return ;} +extern "C" vtkSuperquadric * vtkSuperquadric_new () {return vtkSuperquadric :: New () ;} +extern "C" void vtkSuperquadric_destructor (vtkSuperquadric * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_superquadric_set_center(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_superquadric_set_scale(vtkSuperquadric* sself, double _arg1, double _arg2, double _arg3) { sself->SetScale(_arg1, _arg2, _arg3); } +extern "C" double vtk_superquadric_get_thickness(vtkSuperquadric* sself) { return sself->GetThickness(); } +extern "C" void vtk_superquadric_set_thickness(vtkSuperquadric* sself, double _arg) { sself->SetThickness(_arg); } +extern "C" double vtk_superquadric_get_thickness_min_value(vtkSuperquadric* sself) { return sself->GetThicknessMinValue(); } +extern "C" double vtk_superquadric_get_thickness_max_value(vtkSuperquadric* sself) { return sself->GetThicknessMaxValue(); } +extern "C" double vtk_superquadric_get_phi_roundness(vtkSuperquadric* sself) { return sself->GetPhiRoundness(); } +extern "C" void vtk_superquadric_set_phi_roundness(vtkSuperquadric* sself, double e) { sself->SetPhiRoundness(e); } +extern "C" double vtk_superquadric_get_theta_roundness(vtkSuperquadric* sself) { return sself->GetThetaRoundness(); } +extern "C" void vtk_superquadric_set_theta_roundness(vtkSuperquadric* sself, double e) { sself->SetThetaRoundness(e); } +extern "C" void vtk_superquadric_set_size(vtkSuperquadric* sself, double _arg) { sself->SetSize(_arg); } +extern "C" double vtk_superquadric_get_size(vtkSuperquadric* sself) { return sself->GetSize(); } +extern "C" void vtk_superquadric_toroidal_on(vtkSuperquadric* sself) { sself->ToroidalOn(); } +extern "C" void vtk_superquadric_toroidal_off(vtkSuperquadric* sself) { sself->ToroidalOff(); } +extern "C" int vtk_superquadric_get_toroidal(vtkSuperquadric* sself) { return sself->GetToroidal(); } +extern "C" void vtk_superquadric_set_toroidal(vtkSuperquadric* sself, int _arg) { sself->SetToroidal(_arg); } +extern "C" vtkTable * vtkTable_new () {return vtkTable :: New () ;} +extern "C" void vtkTable_destructor (vtkTable * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_table_dump(vtkTable* sself, unsigned int colWidth, int rowLimit) { sself->Dump(colWidth, rowLimit); } +extern "C" int vtk_table_get_data_object_type(vtkTable* sself) { return sself->GetDataObjectType(); } +extern "C" long long vtk_table_get_number_of_rows(vtkTable* sself) { return sself->GetNumberOfRows(); } +extern "C" void vtk_table_set_number_of_rows(vtkTable* sself, const long long p0) { sself->SetNumberOfRows(p0); } +extern "C" long long vtk_table_insert_next_blank_row(vtkTable* sself, double default_num_val) { return sself->InsertNextBlankRow(default_num_val); } +extern "C" void vtk_table_remove_row(vtkTable* sself, long long row) { sself->RemoveRow(row); } +extern "C" long long vtk_table_get_number_of_columns(vtkTable* sself) { return sself->GetNumberOfColumns(); } +extern "C" const char* vtk_table_get_column_name(vtkTable* sself, long long col) { return sself->GetColumnName(col); } +extern "C" void vtk_table_remove_column_by_name(vtkTable* sself, const char* name) { sself->RemoveColumnByName(name); } +extern "C" void vtk_table_remove_column(vtkTable* sself, long long col) { sself->RemoveColumn(col); } +extern "C" void vtk_table_initialize(vtkTable* sself) { sself->Initialize(); } +extern "C" long long vtk_table_get_number_of_elements(vtkTable* sself, int type) { return sself->GetNumberOfElements(type); } +extern "C" vtkTetra * vtkTetra_new () {return vtkTetra :: New () ;} +extern "C" void vtkTetra_destructor (vtkTetra * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_tetra_get_cell_type(vtkTetra* sself) { return sself->GetCellType(); } +extern "C" int vtk_tetra_get_number_of_edges(vtkTetra* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tetra_get_number_of_faces(vtkTetra* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkTree * vtkTree_new () {return vtkTree :: New () ;} +extern "C" void vtkTree_destructor (vtkTree * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_tree_get_root(vtkTree* sself) { return sself->GetRoot(); } +extern "C" long long vtk_tree_get_number_of_children(vtkTree* sself, long long v) { return sself->GetNumberOfChildren(v); } +extern "C" long long vtk_tree_get_child(vtkTree* sself, long long v, long long i) { return sself->GetChild(v, i); } +extern "C" long long vtk_tree_get_parent(vtkTree* sself, long long v) { return sself->GetParent(v); } +extern "C" long long vtk_tree_get_level(vtkTree* sself, long long v) { return sself->GetLevel(v); } +extern "C" bool vtk_tree_is_leaf(vtkTree* sself, long long vertex) { return sself->IsLeaf(vertex); } +extern "C" vtkTreeBFSIterator * vtkTreeBFSIterator_new () {return vtkTreeBFSIterator :: New () ;} +extern "C" void vtkTreeBFSIterator_destructor (vtkTreeBFSIterator * sself) {sself -> Delete () ; return ;} +extern "C" vtkTreeDFSIterator * vtkTreeDFSIterator_new () {return vtkTreeDFSIterator :: New () ;} +extern "C" void vtkTreeDFSIterator_destructor (vtkTreeDFSIterator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_tree_dfs_iterator_set_mode(vtkTreeDFSIterator* sself, int mode) { sself->SetMode(mode); } +extern "C" int vtk_tree_dfs_iterator_get_mode(vtkTreeDFSIterator* sself) { return sself->GetMode(); } +extern "C" vtkTriQuadraticHexahedron * vtkTriQuadraticHexahedron_new () {return vtkTriQuadraticHexahedron :: New () ;} +extern "C" void vtkTriQuadraticHexahedron_destructor (vtkTriQuadraticHexahedron * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_type(vtkTriQuadraticHexahedron* sself) { return sself->GetCellType(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_cell_dimension(vtkTriQuadraticHexahedron* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_edges(vtkTriQuadraticHexahedron* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tri_quadratic_hexahedron_get_number_of_faces(vtkTriQuadraticHexahedron* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkTriQuadraticPyramid * vtkTriQuadraticPyramid_new () {return vtkTriQuadraticPyramid :: New () ;} +extern "C" void vtkTriQuadraticPyramid_destructor (vtkTriQuadraticPyramid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_tri_quadratic_pyramid_get_cell_type(vtkTriQuadraticPyramid* sself) { return sself->GetCellType(); } +extern "C" int vtk_tri_quadratic_pyramid_get_cell_dimension(vtkTriQuadraticPyramid* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_edges(vtkTriQuadraticPyramid* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_tri_quadratic_pyramid_get_number_of_faces(vtkTriQuadraticPyramid* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkTriangle * vtkTriangle_new () {return vtkTriangle :: New () ;} +extern "C" void vtkTriangle_destructor (vtkTriangle * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_triangle_get_cell_type(vtkTriangle* sself) { return sself->GetCellType(); } +extern "C" int vtk_triangle_get_cell_dimension(vtkTriangle* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_triangle_get_number_of_edges(vtkTriangle* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_triangle_get_number_of_faces(vtkTriangle* sself) { return sself->GetNumberOfFaces(); } +extern "C" double vtk_triangle_compute_area(vtkTriangle* sself) { return sself->ComputeArea(); } +extern "C" vtkTriangleStrip * vtkTriangleStrip_new () {return vtkTriangleStrip :: New () ;} +extern "C" void vtkTriangleStrip_destructor (vtkTriangleStrip * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_triangle_strip_get_cell_type(vtkTriangleStrip* sself) { return sself->GetCellType(); } +extern "C" int vtk_triangle_strip_get_cell_dimension(vtkTriangleStrip* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_triangle_strip_get_number_of_edges(vtkTriangleStrip* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_triangle_strip_get_number_of_faces(vtkTriangleStrip* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkUndirectedGraph * vtkUndirectedGraph_new () {return vtkUndirectedGraph :: New () ;} +extern "C" void vtkUndirectedGraph_destructor (vtkUndirectedGraph * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_undirected_graph_get_in_degree(vtkUndirectedGraph* sself, long long v) { return sself->GetInDegree(v); } +extern "C" vtkUniformGrid * vtkUniformGrid_new () {return vtkUniformGrid :: New () ;} +extern "C" void vtkUniformGrid_destructor (vtkUniformGrid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_uniform_grid_get_grid_description(vtkUniformGrid* sself) { return sself->GetGridDescription(); } +extern "C" void vtk_uniform_grid_blank_point(vtkUniformGrid* sself, long long ptId) { sself->BlankPoint(ptId); } +extern "C" void vtk_uniform_grid_un_blank_point(vtkUniformGrid* sself, long long ptId) { sself->UnBlankPoint(ptId); } +extern "C" void vtk_uniform_grid_blank_cell(vtkUniformGrid* sself, long long ptId) { sself->BlankCell(ptId); } +extern "C" void vtk_uniform_grid_un_blank_cell(vtkUniformGrid* sself, long long ptId) { sself->UnBlankCell(ptId); } +extern "C" unsigned char vtk_uniform_grid_is_point_visible(vtkUniformGrid* sself, long long pointId) { return sself->IsPointVisible(pointId); } +extern "C" unsigned char vtk_uniform_grid_is_cell_visible(vtkUniformGrid* sself, long long cellId) { return sself->IsCellVisible(cellId); } +extern "C" vtkUniformGridAMR * vtkUniformGridAMR_new () {return vtkUniformGridAMR :: New () ;} +extern "C" void vtkUniformGridAMR_destructor (vtkUniformGridAMR * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_uniform_grid_amr_get_data_object_type(vtkUniformGridAMR* sself) { return sself->GetDataObjectType(); } +extern "C" void vtk_uniform_grid_amr_initialize(vtkUniformGridAMR* sself) { sself->Initialize(); } +extern "C" void vtk_uniform_grid_amr_set_grid_description(vtkUniformGridAMR* sself, int gridDescription) { sself->SetGridDescription(gridDescription); } +extern "C" int vtk_uniform_grid_amr_get_grid_description(vtkUniformGridAMR* sself) { return sself->GetGridDescription(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_levels(vtkUniformGridAMR* sself) { return sself->GetNumberOfLevels(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_total_number_of_blocks(vtkUniformGridAMR* sself) { return sself->GetTotalNumberOfBlocks(); } +extern "C" unsigned int vtk_uniform_grid_amr_get_number_of_data_sets(vtkUniformGridAMR* sself, const unsigned int level) { return sself->GetNumberOfDataSets(level); } +extern "C" int vtk_uniform_grid_amr_get_composite_index(vtkUniformGridAMR* sself, const unsigned int level, const unsigned int index) { return sself->GetCompositeIndex(level, index); } +extern "C" void vtk_uniform_grid_amr_get_level_and_index(vtkUniformGridAMR* sself, const unsigned int compositeIdx, unsigned int& level, unsigned int& idx) { sself->GetLevelAndIndex(compositeIdx, level, idx); } +extern "C" vtkUniformGridAMRDataIterator * vtkUniformGridAMRDataIterator_new () {return vtkUniformGridAMRDataIterator :: New () ;} +extern "C" void vtkUniformGridAMRDataIterator_destructor (vtkUniformGridAMRDataIterator * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_uniform_grid_amr_data_iterator_has_current_meta_data(vtkUniformGridAMRDataIterator* sself) { return sself->HasCurrentMetaData(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_flat_index(vtkUniformGridAMRDataIterator* sself) { return sself->GetCurrentFlatIndex(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_level(vtkUniformGridAMRDataIterator* sself) { return sself->GetCurrentLevel(); } +extern "C" unsigned int vtk_uniform_grid_amr_data_iterator_get_current_index(vtkUniformGridAMRDataIterator* sself) { return sself->GetCurrentIndex(); } +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_first_item(vtkUniformGridAMRDataIterator* sself) { sself->GoToFirstItem(); } +extern "C" void vtk_uniform_grid_amr_data_iterator_go_to_next_item(vtkUniformGridAMRDataIterator* sself) { sself->GoToNextItem(); } +extern "C" int vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(vtkUniformGridAMRDataIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" vtkUniformHyperTreeGrid * vtkUniformHyperTreeGrid_new () {return vtkUniformHyperTreeGrid :: New () ;} +extern "C" void vtkUniformHyperTreeGrid_destructor (vtkUniformHyperTreeGrid * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_uniform_hyper_tree_grid_set_origin(vtkUniformHyperTreeGrid* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_uniform_hyper_tree_grid_set_grid_scale(vtkUniformHyperTreeGrid* sself, double p0, double p1, double p2) { sself->SetGridScale(p0, p1, p2); } +extern "C" unsigned long vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(vtkUniformHyperTreeGrid* sself) { return sself->GetActualMemorySizeBytes(); } +extern "C" vtkUnstructuredGrid * vtkUnstructuredGrid_new () {return vtkUnstructuredGrid :: New () ;} +extern "C" void vtkUnstructuredGrid_destructor (vtkUnstructuredGrid * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_unstructured_grid_get_data_object_type(vtkUnstructuredGrid* sself) { return sself->GetDataObjectType(); } +extern "C" bool vtk_unstructured_grid_allocate_estimate(vtkUnstructuredGrid* sself, long long numCells, long long maxCellSize) { return sself->AllocateEstimate(numCells, maxCellSize); } +extern "C" bool vtk_unstructured_grid_allocate_exact(vtkUnstructuredGrid* sself, long long numCells, long long connectivitySize) { return sself->AllocateExact(numCells, connectivitySize); } +extern "C" void vtk_unstructured_grid_allocate(vtkUnstructuredGrid* sself, long long numCells, int extSize) { sself->Allocate(numCells, extSize); } +extern "C" void vtk_unstructured_grid_reset(vtkUnstructuredGrid* sself) { sself->Reset(); } +extern "C" int vtk_unstructured_grid_get_cell_type(vtkUnstructuredGrid* sself, long long cellId) { return sself->GetCellType(cellId); } +extern "C" void vtk_unstructured_grid_squeeze(vtkUnstructuredGrid* sself) { sself->Squeeze(); } +extern "C" void vtk_unstructured_grid_initialize(vtkUnstructuredGrid* sself) { sself->Initialize(); } +extern "C" int vtk_unstructured_grid_get_max_cell_size(vtkUnstructuredGrid* sself) { return sself->GetMaxCellSize(); } +extern "C" void vtk_unstructured_grid_build_links(vtkUnstructuredGrid* sself) { sself->BuildLinks(); } +extern "C" void vtk_unstructured_grid_remove_reference_to_cell(vtkUnstructuredGrid* sself, long long ptId, long long cellId) { sself->RemoveReferenceToCell(ptId, cellId); } +extern "C" void vtk_unstructured_grid_add_reference_to_cell(vtkUnstructuredGrid* sself, long long ptId, long long cellId) { sself->AddReferenceToCell(ptId, cellId); } +extern "C" void vtk_unstructured_grid_resize_cell_list(vtkUnstructuredGrid* sself, long long ptId, int size) { sself->ResizeCellList(ptId, size); } +extern "C" int vtk_unstructured_grid_get_piece(vtkUnstructuredGrid* sself) { return sself->GetPiece(); } +extern "C" int vtk_unstructured_grid_get_number_of_pieces(vtkUnstructuredGrid* sself) { return sself->GetNumberOfPieces(); } +extern "C" int vtk_unstructured_grid_get_ghost_level(vtkUnstructuredGrid* sself) { return sself->GetGhostLevel(); } +extern "C" int vtk_unstructured_grid_is_homogeneous(vtkUnstructuredGrid* sself) { return sself->IsHomogeneous(); } +extern "C" void vtk_unstructured_grid_remove_ghost_cells(vtkUnstructuredGrid* sself) { sself->RemoveGhostCells(); } +extern "C" int vtk_unstructured_grid_initialize_faces_representation(vtkUnstructuredGrid* sself, long long numPrevCells) { return sself->InitializeFacesRepresentation(numPrevCells); } +extern "C" unsigned long vtk_unstructured_grid_get_mesh_m_time(vtkUnstructuredGrid* sself) { return sself->GetMeshMTime(); } +extern "C" vtkUnstructuredGridCellIterator * vtkUnstructuredGridCellIterator_new () {return vtkUnstructuredGridCellIterator :: New () ;} +extern "C" void vtkUnstructuredGridCellIterator_destructor (vtkUnstructuredGridCellIterator * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_unstructured_grid_cell_iterator_is_done_with_traversal(vtkUnstructuredGridCellIterator* sself) { return sself->IsDoneWithTraversal(); } +extern "C" long long vtk_unstructured_grid_cell_iterator_get_cell_id(vtkUnstructuredGridCellIterator* sself) { return sself->GetCellId(); } +extern "C" void vtk_unstructured_grid_cell_iterator_go_to_cell(vtkUnstructuredGridCellIterator* sself, long long cellId) { sself->GoToCell(cellId); } +extern "C" vtkVertex * vtkVertex_new () {return vtkVertex :: New () ;} +extern "C" void vtkVertex_destructor (vtkVertex * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_vertex_get_cell_type(vtkVertex* sself) { return sself->GetCellType(); } +extern "C" int vtk_vertex_get_cell_dimension(vtkVertex* sself) { return sself->GetCellDimension(); } +extern "C" int vtk_vertex_get_number_of_edges(vtkVertex* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_vertex_get_number_of_faces(vtkVertex* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_vertex_inflate(vtkVertex* sself, double p0) { return sself->Inflate(p0); } +extern "C" vtkVertexListIterator * vtkVertexListIterator_new () {return vtkVertexListIterator :: New () ;} +extern "C" void vtkVertexListIterator_destructor (vtkVertexListIterator * sself) {sself -> Delete () ; return ;} +extern "C" long long vtk_vertex_list_iterator_next(vtkVertexListIterator* sself) { return sself->Next(); } +extern "C" bool vtk_vertex_list_iterator_has_next(vtkVertexListIterator* sself) { return sself->HasNext(); } +extern "C" vtkVoxel * vtkVoxel_new () {return vtkVoxel :: New () ;} +extern "C" void vtkVoxel_destructor (vtkVoxel * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_voxel_get_cell_type(vtkVoxel* sself) { return sself->GetCellType(); } +extern "C" int vtk_voxel_get_number_of_edges(vtkVoxel* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_voxel_get_number_of_faces(vtkVoxel* sself) { return sself->GetNumberOfFaces(); } +extern "C" int vtk_voxel_inflate(vtkVoxel* sself, double dist) { return sself->Inflate(dist); } +extern "C" vtkWedge * vtkWedge_new () {return vtkWedge :: New () ;} +extern "C" void vtkWedge_destructor (vtkWedge * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_wedge_get_cell_type(vtkWedge* sself) { return sself->GetCellType(); } +extern "C" int vtk_wedge_get_number_of_edges(vtkWedge* sself) { return sself->GetNumberOfEdges(); } +extern "C" int vtk_wedge_get_number_of_faces(vtkWedge* sself) { return sself->GetNumberOfFaces(); } +extern "C" vtkXMLDataElement * vtkXMLDataElement_new () {return vtkXMLDataElement :: New () ;} +extern "C" void vtkXMLDataElement_destructor (vtkXMLDataElement * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_xml_data_element_set_name(vtkXMLDataElement* sself, const char* _arg) { sself->SetName(_arg); } +extern "C" void vtk_xml_data_element_set_id(vtkXMLDataElement* sself, const char* _arg) { sself->SetId(_arg); } +extern "C" const char* vtk_xml_data_element_get_attribute(vtkXMLDataElement* sself, const char* name) { return sself->GetAttribute(name); } +extern "C" void vtk_xml_data_element_set_attribute(vtkXMLDataElement* sself, const char* name, const char* value) { sself->SetAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_character_data(vtkXMLDataElement* sself, const char* data, int length) { sself->SetCharacterData(data, length); } +extern "C" void vtk_xml_data_element_add_character_data(vtkXMLDataElement* sself, const char* c, size_t length) { sself->AddCharacterData(c, length); } +extern "C" int vtk_xml_data_element_get_scalar_attribute(vtkXMLDataElement* sself, const char* name, int& value) { return sself->GetScalarAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_int_attribute(vtkXMLDataElement* sself, const char* name, int value) { sself->SetIntAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_float_attribute(vtkXMLDataElement* sself, const char* name, float value) { sself->SetFloatAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_double_attribute(vtkXMLDataElement* sself, const char* name, double value) { sself->SetDoubleAttribute(name, value); } +extern "C" void vtk_xml_data_element_set_unsigned_long_attribute(vtkXMLDataElement* sself, const char* name, unsigned long value) { sself->SetUnsignedLongAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_word_type_attribute(vtkXMLDataElement* sself, const char* name, int& value) { return sself->GetWordTypeAttribute(name, value); } +extern "C" int vtk_xml_data_element_get_number_of_attributes(vtkXMLDataElement* sself) { return sself->GetNumberOfAttributes(); } +extern "C" const char* vtk_xml_data_element_get_attribute_name(vtkXMLDataElement* sself, int idx) { return sself->GetAttributeName(idx); } +extern "C" const char* vtk_xml_data_element_get_attribute_value(vtkXMLDataElement* sself, int idx) { return sself->GetAttributeValue(idx); } +extern "C" void vtk_xml_data_element_remove_attribute(vtkXMLDataElement* sself, const char* name) { sself->RemoveAttribute(name); } +extern "C" void vtk_xml_data_element_remove_all_attributes(vtkXMLDataElement* sself) { sself->RemoveAllAttributes(); } +extern "C" int vtk_xml_data_element_get_number_of_nested_elements(vtkXMLDataElement* sself) { return sself->GetNumberOfNestedElements(); } +extern "C" void vtk_xml_data_element_remove_all_nested_elements(vtkXMLDataElement* sself) { sself->RemoveAllNestedElements(); } +extern "C" long long vtk_xml_data_element_get_xml_byte_index(vtkXMLDataElement* sself) { return sself->GetXMLByteIndex(); } +extern "C" void vtk_xml_data_element_set_xml_byte_index(vtkXMLDataElement* sself, long long _arg) { sself->SetXMLByteIndex(_arg); } +extern "C" void vtk_xml_data_element_set_attribute_encoding(vtkXMLDataElement* sself, int _arg) { sself->SetAttributeEncoding(_arg); } +extern "C" int vtk_xml_data_element_get_attribute_encoding_min_value(vtkXMLDataElement* sself) { return sself->GetAttributeEncodingMinValue(); } +extern "C" int vtk_xml_data_element_get_attribute_encoding_max_value(vtkXMLDataElement* sself) { return sself->GetAttributeEncodingMaxValue(); } +extern "C" int vtk_xml_data_element_get_attribute_encoding(vtkXMLDataElement* sself) { return sself->GetAttributeEncoding(); } +extern "C" void vtk_xml_data_element_print_xml(vtkXMLDataElement* sself, const char* fname) { sself->PrintXML(fname); } +extern "C" int vtk_xml_data_element_get_character_data_width(vtkXMLDataElement* sself) { return sself->GetCharacterDataWidth(); } +extern "C" void vtk_xml_data_element_set_character_data_width(vtkXMLDataElement* sself, int _arg) { sself->SetCharacterDataWidth(_arg); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp index ebd83c3..a809822 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_execution_model.cpp @@ -77,156 +77,268 @@ #include // Implement declared functions -extern "C" vtkNew < vtkAlgorithm > vtkAlgorithm_new () {return vtkNew < vtkAlgorithm > () ;} -extern "C" void vtkAlgorithm_destructor (vtkNew < vtkAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAlgorithm_get_ptr (vtkNew < vtkAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkAlgorithmOutput > vtkAlgorithmOutput_new () {return vtkNew < vtkAlgorithmOutput > () ;} -extern "C" void vtkAlgorithmOutput_destructor (vtkNew < vtkAlgorithmOutput > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAlgorithmOutput_get_ptr (vtkNew < vtkAlgorithmOutput > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkAnnotationLayersAlgorithm > vtkAnnotationLayersAlgorithm_new () {return vtkNew < vtkAnnotationLayersAlgorithm > () ;} -extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkNew < vtkAnnotationLayersAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAnnotationLayersAlgorithm_get_ptr (vtkNew < vtkAnnotationLayersAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkArrayDataAlgorithm > vtkArrayDataAlgorithm_new () {return vtkNew < vtkArrayDataAlgorithm > () ;} -extern "C" void vtkArrayDataAlgorithm_destructor (vtkNew < vtkArrayDataAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkArrayDataAlgorithm_get_ptr (vtkNew < vtkArrayDataAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCachedStreamingDemandDrivenPipeline > vtkCachedStreamingDemandDrivenPipeline_new () {return vtkNew < vtkCachedStreamingDemandDrivenPipeline > () ;} -extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCachedStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkCachedStreamingDemandDrivenPipeline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCastToConcrete > vtkCastToConcrete_new () {return vtkNew < vtkCastToConcrete > () ;} -extern "C" void vtkCastToConcrete_destructor (vtkNew < vtkCastToConcrete > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCastToConcrete_get_ptr (vtkNew < vtkCastToConcrete > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCompositeDataPipeline > vtkCompositeDataPipeline_new () {return vtkNew < vtkCompositeDataPipeline > () ;} -extern "C" void vtkCompositeDataPipeline_destructor (vtkNew < vtkCompositeDataPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCompositeDataPipeline_get_ptr (vtkNew < vtkCompositeDataPipeline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkCompositeDataSetAlgorithm > vtkCompositeDataSetAlgorithm_new () {return vtkNew < vtkCompositeDataSetAlgorithm > () ;} -extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkNew < vtkCompositeDataSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCompositeDataSetAlgorithm_get_ptr (vtkNew < vtkCompositeDataSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataObjectAlgorithm > vtkDataObjectAlgorithm_new () {return vtkNew < vtkDataObjectAlgorithm > () ;} -extern "C" void vtkDataObjectAlgorithm_destructor (vtkNew < vtkDataObjectAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataObjectAlgorithm_get_ptr (vtkNew < vtkDataObjectAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDataSetAlgorithm > vtkDataSetAlgorithm_new () {return vtkNew < vtkDataSetAlgorithm > () ;} -extern "C" void vtkDataSetAlgorithm_destructor (vtkNew < vtkDataSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDataSetAlgorithm_get_ptr (vtkNew < vtkDataSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDemandDrivenPipeline > vtkDemandDrivenPipeline_new () {return vtkNew < vtkDemandDrivenPipeline > () ;} -extern "C" void vtkDemandDrivenPipeline_destructor (vtkNew < vtkDemandDrivenPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDemandDrivenPipeline_get_ptr (vtkNew < vtkDemandDrivenPipeline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDirectedGraphAlgorithm > vtkDirectedGraphAlgorithm_new () {return vtkNew < vtkDirectedGraphAlgorithm > () ;} -extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkNew < vtkDirectedGraphAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDirectedGraphAlgorithm_get_ptr (vtkNew < vtkDirectedGraphAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkEnsembleSource > vtkEnsembleSource_new () {return vtkNew < vtkEnsembleSource > () ;} -extern "C" void vtkEnsembleSource_destructor (vtkNew < vtkEnsembleSource > sself) {sself . Reset () ; return ;} -extern "C" void * vtkEnsembleSource_get_ptr (vtkNew < vtkEnsembleSource > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExplicitStructuredGridAlgorithm > vtkExplicitStructuredGridAlgorithm_new () {return vtkNew < vtkExplicitStructuredGridAlgorithm > () ;} -extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExplicitStructuredGridAlgorithm_get_ptr (vtkNew < vtkExplicitStructuredGridAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExtentRCBPartitioner > vtkExtentRCBPartitioner_new () {return vtkNew < vtkExtentRCBPartitioner > () ;} -extern "C" void vtkExtentRCBPartitioner_destructor (vtkNew < vtkExtentRCBPartitioner > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExtentRCBPartitioner_get_ptr (vtkNew < vtkExtentRCBPartitioner > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExtentSplitter > vtkExtentSplitter_new () {return vtkNew < vtkExtentSplitter > () ;} -extern "C" void vtkExtentSplitter_destructor (vtkNew < vtkExtentSplitter > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExtentSplitter_get_ptr (vtkNew < vtkExtentSplitter > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExtentTranslator > vtkExtentTranslator_new () {return vtkNew < vtkExtentTranslator > () ;} -extern "C" void vtkExtentTranslator_destructor (vtkNew < vtkExtentTranslator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExtentTranslator_get_ptr (vtkNew < vtkExtentTranslator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGraphAlgorithm > vtkGraphAlgorithm_new () {return vtkNew < vtkGraphAlgorithm > () ;} -extern "C" void vtkGraphAlgorithm_destructor (vtkNew < vtkGraphAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGraphAlgorithm_get_ptr (vtkNew < vtkGraphAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHierarchicalBoxDataSetAlgorithm > vtkHierarchicalBoxDataSetAlgorithm_new () {return vtkNew < vtkHierarchicalBoxDataSetAlgorithm > () ;} -extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkNew < vtkHierarchicalBoxDataSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHierarchicalBoxDataSetAlgorithm_get_ptr (vtkNew < vtkHierarchicalBoxDataSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImageToStructuredGrid > vtkImageToStructuredGrid_new () {return vtkNew < vtkImageToStructuredGrid > () ;} -extern "C" void vtkImageToStructuredGrid_destructor (vtkNew < vtkImageToStructuredGrid > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImageToStructuredGrid_get_ptr (vtkNew < vtkImageToStructuredGrid > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkImageToStructuredPoints > vtkImageToStructuredPoints_new () {return vtkNew < vtkImageToStructuredPoints > () ;} -extern "C" void vtkImageToStructuredPoints_destructor (vtkNew < vtkImageToStructuredPoints > sself) {sself . Reset () ; return ;} -extern "C" void * vtkImageToStructuredPoints_get_ptr (vtkNew < vtkImageToStructuredPoints > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMoleculeAlgorithm > vtkMoleculeAlgorithm_new () {return vtkNew < vtkMoleculeAlgorithm > () ;} -extern "C" void vtkMoleculeAlgorithm_destructor (vtkNew < vtkMoleculeAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMoleculeAlgorithm_get_ptr (vtkNew < vtkMoleculeAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMultiBlockDataSetAlgorithm > vtkMultiBlockDataSetAlgorithm_new () {return vtkNew < vtkMultiBlockDataSetAlgorithm > () ;} -extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkNew < vtkMultiBlockDataSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiBlockDataSetAlgorithm_get_ptr (vtkNew < vtkMultiBlockDataSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMultiTimeStepAlgorithm > vtkMultiTimeStepAlgorithm_new () {return vtkNew < vtkMultiTimeStepAlgorithm > () ;} -extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkNew < vtkMultiTimeStepAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMultiTimeStepAlgorithm_get_ptr (vtkNew < vtkMultiTimeStepAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkNonOverlappingAMRAlgorithm > vtkNonOverlappingAMRAlgorithm_new () {return vtkNew < vtkNonOverlappingAMRAlgorithm > () ;} -extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNew < vtkNonOverlappingAMRAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkNonOverlappingAMRAlgorithm_get_ptr (vtkNew < vtkNonOverlappingAMRAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkOverlappingAMRAlgorithm > vtkOverlappingAMRAlgorithm_new () {return vtkNew < vtkOverlappingAMRAlgorithm > () ;} -extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkNew < vtkOverlappingAMRAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkOverlappingAMRAlgorithm_get_ptr (vtkNew < vtkOverlappingAMRAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPassInputTypeAlgorithm > vtkPassInputTypeAlgorithm_new () {return vtkNew < vtkPassInputTypeAlgorithm > () ;} -extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkNew < vtkPassInputTypeAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPassInputTypeAlgorithm_get_ptr (vtkNew < vtkPassInputTypeAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPiecewiseFunctionAlgorithm > vtkPiecewiseFunctionAlgorithm_new () {return vtkNew < vtkPiecewiseFunctionAlgorithm > () ;} -extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkNew < vtkPiecewiseFunctionAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPiecewiseFunctionAlgorithm_get_ptr (vtkNew < vtkPiecewiseFunctionAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPiecewiseFunctionShiftScale > vtkPiecewiseFunctionShiftScale_new () {return vtkNew < vtkPiecewiseFunctionShiftScale > () ;} -extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkNew < vtkPiecewiseFunctionShiftScale > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPiecewiseFunctionShiftScale_get_ptr (vtkNew < vtkPiecewiseFunctionShiftScale > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPointSetAlgorithm > vtkPointSetAlgorithm_new () {return vtkNew < vtkPointSetAlgorithm > () ;} -extern "C" void vtkPointSetAlgorithm_destructor (vtkNew < vtkPointSetAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPointSetAlgorithm_get_ptr (vtkNew < vtkPointSetAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolyDataAlgorithm > vtkPolyDataAlgorithm_new () {return vtkNew < vtkPolyDataAlgorithm > () ;} -extern "C" void vtkPolyDataAlgorithm_destructor (vtkNew < vtkPolyDataAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolyDataAlgorithm_get_ptr (vtkNew < vtkPolyDataAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkProgressObserver > vtkProgressObserver_new () {return vtkNew < vtkProgressObserver > () ;} -extern "C" void vtkProgressObserver_destructor (vtkNew < vtkProgressObserver > sself) {sself . Reset () ; return ;} -extern "C" void * vtkProgressObserver_get_ptr (vtkNew < vtkProgressObserver > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkReaderExecutive > vtkReaderExecutive_new () {return vtkNew < vtkReaderExecutive > () ;} -extern "C" void vtkReaderExecutive_destructor (vtkNew < vtkReaderExecutive > sself) {sself . Reset () ; return ;} -extern "C" void * vtkReaderExecutive_get_ptr (vtkNew < vtkReaderExecutive > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkRectilinearGridAlgorithm > vtkRectilinearGridAlgorithm_new () {return vtkNew < vtkRectilinearGridAlgorithm > () ;} -extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkNew < vtkRectilinearGridAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRectilinearGridAlgorithm_get_ptr (vtkNew < vtkRectilinearGridAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSMPProgressObserver > vtkSMPProgressObserver_new () {return vtkNew < vtkSMPProgressObserver > () ;} -extern "C" void vtkSMPProgressObserver_destructor (vtkNew < vtkSMPProgressObserver > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSMPProgressObserver_get_ptr (vtkNew < vtkSMPProgressObserver > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSelectionAlgorithm > vtkSelectionAlgorithm_new () {return vtkNew < vtkSelectionAlgorithm > () ;} -extern "C" void vtkSelectionAlgorithm_destructor (vtkNew < vtkSelectionAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSelectionAlgorithm_get_ptr (vtkNew < vtkSelectionAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSimpleScalarTree > vtkSimpleScalarTree_new () {return vtkNew < vtkSimpleScalarTree > () ;} -extern "C" void vtkSimpleScalarTree_destructor (vtkNew < vtkSimpleScalarTree > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSimpleScalarTree_get_ptr (vtkNew < vtkSimpleScalarTree > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSpanSpace > vtkSpanSpace_new () {return vtkNew < vtkSpanSpace > () ;} -extern "C" void vtkSpanSpace_destructor (vtkNew < vtkSpanSpace > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSpanSpace_get_ptr (vtkNew < vtkSpanSpace > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSphereTree > vtkSphereTree_new () {return vtkNew < vtkSphereTree > () ;} -extern "C" void vtkSphereTree_destructor (vtkNew < vtkSphereTree > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSphereTree_get_ptr (vtkNew < vtkSphereTree > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStreamingDemandDrivenPipeline > vtkStreamingDemandDrivenPipeline_new () {return vtkNew < vtkStreamingDemandDrivenPipeline > () ;} -extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkNew < vtkStreamingDemandDrivenPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStreamingDemandDrivenPipeline_get_ptr (vtkNew < vtkStreamingDemandDrivenPipeline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkStructuredGridAlgorithm > vtkStructuredGridAlgorithm_new () {return vtkNew < vtkStructuredGridAlgorithm > () ;} -extern "C" void vtkStructuredGridAlgorithm_destructor (vtkNew < vtkStructuredGridAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkStructuredGridAlgorithm_get_ptr (vtkNew < vtkStructuredGridAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTableAlgorithm > vtkTableAlgorithm_new () {return vtkNew < vtkTableAlgorithm > () ;} -extern "C" void vtkTableAlgorithm_destructor (vtkNew < vtkTableAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTableAlgorithm_get_ptr (vtkNew < vtkTableAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkThreadedCompositeDataPipeline > vtkThreadedCompositeDataPipeline_new () {return vtkNew < vtkThreadedCompositeDataPipeline > () ;} -extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkNew < vtkThreadedCompositeDataPipeline > sself) {sself . Reset () ; return ;} -extern "C" void * vtkThreadedCompositeDataPipeline_get_ptr (vtkNew < vtkThreadedCompositeDataPipeline > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTreeAlgorithm > vtkTreeAlgorithm_new () {return vtkNew < vtkTreeAlgorithm > () ;} -extern "C" void vtkTreeAlgorithm_destructor (vtkNew < vtkTreeAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTreeAlgorithm_get_ptr (vtkNew < vtkTreeAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTrivialConsumer > vtkTrivialConsumer_new () {return vtkNew < vtkTrivialConsumer > () ;} -extern "C" void vtkTrivialConsumer_destructor (vtkNew < vtkTrivialConsumer > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTrivialConsumer_get_ptr (vtkNew < vtkTrivialConsumer > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTrivialProducer > vtkTrivialProducer_new () {return vtkNew < vtkTrivialProducer > () ;} -extern "C" void vtkTrivialProducer_destructor (vtkNew < vtkTrivialProducer > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTrivialProducer_get_ptr (vtkNew < vtkTrivialProducer > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUndirectedGraphAlgorithm > vtkUndirectedGraphAlgorithm_new () {return vtkNew < vtkUndirectedGraphAlgorithm > () ;} -extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkNew < vtkUndirectedGraphAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUndirectedGraphAlgorithm_get_ptr (vtkNew < vtkUndirectedGraphAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUniformGridAMRAlgorithm > vtkUniformGridAMRAlgorithm_new () {return vtkNew < vtkUniformGridAMRAlgorithm > () ;} -extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkNew < vtkUniformGridAMRAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGridAMRAlgorithm_get_ptr (vtkNew < vtkUniformGridAMRAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUniformGridPartitioner > vtkUniformGridPartitioner_new () {return vtkNew < vtkUniformGridPartitioner > () ;} -extern "C" void vtkUniformGridPartitioner_destructor (vtkNew < vtkUniformGridPartitioner > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUniformGridPartitioner_get_ptr (vtkNew < vtkUniformGridPartitioner > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnstructuredGridAlgorithm > vtkUnstructuredGridAlgorithm_new () {return vtkNew < vtkUnstructuredGridAlgorithm > () ;} -extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkNew < vtkUnstructuredGridAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnstructuredGridAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridAlgorithm > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkUnstructuredGridBaseAlgorithm > vtkUnstructuredGridBaseAlgorithm_new () {return vtkNew < vtkUnstructuredGridBaseAlgorithm > () ;} -extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkNew < vtkUnstructuredGridBaseAlgorithm > sself) {sself . Reset () ; return ;} -extern "C" void * vtkUnstructuredGridBaseAlgorithm_get_ptr (vtkNew < vtkUnstructuredGridBaseAlgorithm > sself) {return sself . GetPointer () ;} +extern "C" vtkAlgorithm * vtkAlgorithm_new () {return vtkAlgorithm :: New () ;} +extern "C" void vtkAlgorithm_destructor (vtkAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_algorithm_has_executive(vtkAlgorithm* sself) { return sself->HasExecutive(); } +extern "C" int vtk_algorithm_get_number_of_input_ports(vtkAlgorithm* sself) { return sself->GetNumberOfInputPorts(); } +extern "C" int vtk_algorithm_get_number_of_output_ports(vtkAlgorithm* sself) { return sself->GetNumberOfOutputPorts(); } +extern "C" void vtk_algorithm_set_abort_execute(vtkAlgorithm* sself, int _arg) { sself->SetAbortExecute(_arg); } +extern "C" int vtk_algorithm_get_abort_execute(vtkAlgorithm* sself) { return sself->GetAbortExecute(); } +extern "C" void vtk_algorithm_abort_execute_on(vtkAlgorithm* sself) { sself->AbortExecuteOn(); } +extern "C" void vtk_algorithm_abort_execute_off(vtkAlgorithm* sself) { sself->AbortExecuteOff(); } +extern "C" double vtk_algorithm_get_progress(vtkAlgorithm* sself) { return sself->GetProgress(); } +extern "C" void vtk_algorithm_set_progress(vtkAlgorithm* sself, double p0) { sself->SetProgress(p0); } +extern "C" void vtk_algorithm_update_progress(vtkAlgorithm* sself, double amount) { sself->UpdateProgress(amount); } +extern "C" void vtk_algorithm_set_progress_shift_scale(vtkAlgorithm* sself, double shift, double scale) { sself->SetProgressShiftScale(shift, scale); } +extern "C" double vtk_algorithm_get_progress_shift(vtkAlgorithm* sself) { return sself->GetProgressShift(); } +extern "C" double vtk_algorithm_get_progress_scale(vtkAlgorithm* sself) { return sself->GetProgressScale(); } +extern "C" void vtk_algorithm_set_progress_text(vtkAlgorithm* sself, const char* ptext) { sself->SetProgressText(ptext); } +extern "C" unsigned long vtk_algorithm_get_error_code(vtkAlgorithm* sself) { return sself->GetErrorCode(); } +extern "C" void vtk_algorithm_set_input_array_to_process(vtkAlgorithm* sself, int idx, int port, int connection, int fieldAssociation, const char* name) { sself->SetInputArrayToProcess(idx, port, connection, fieldAssociation, name); } +extern "C" void vtk_algorithm_remove_all_inputs(vtkAlgorithm* sself) { sself->RemoveAllInputs(); } +extern "C" void vtk_algorithm_remove_all_input_connections(vtkAlgorithm* sself, int port) { sself->RemoveAllInputConnections(port); } +extern "C" int vtk_algorithm_get_number_of_input_connections(vtkAlgorithm* sself, int port) { return sself->GetNumberOfInputConnections(port); } +extern "C" int vtk_algorithm_get_total_number_of_input_connections(vtkAlgorithm* sself) { return sself->GetTotalNumberOfInputConnections(); } +extern "C" void vtk_algorithm_update(vtkAlgorithm* sself, int port) { sself->Update(port); } +extern "C" void vtk_algorithm_update_information(vtkAlgorithm* sself) { sself->UpdateInformation(); } +extern "C" void vtk_algorithm_update_data_object(vtkAlgorithm* sself) { sself->UpdateDataObject(); } +extern "C" void vtk_algorithm_propagate_update_extent(vtkAlgorithm* sself) { sself->PropagateUpdateExtent(); } +extern "C" void vtk_algorithm_update_whole_extent(vtkAlgorithm* sself) { sself->UpdateWholeExtent(); } +extern "C" void vtk_algorithm_convert_total_input_to_port_connection(vtkAlgorithm* sself, int ind, int& port, int& conn) { sself->ConvertTotalInputToPortConnection(ind, port, conn); } +extern "C" void vtk_algorithm_set_release_data_flag(vtkAlgorithm* sself, int p0) { sself->SetReleaseDataFlag(p0); } +extern "C" int vtk_algorithm_get_release_data_flag(vtkAlgorithm* sself) { return sself->GetReleaseDataFlag(); } +extern "C" void vtk_algorithm_release_data_flag_on(vtkAlgorithm* sself) { sself->ReleaseDataFlagOn(); } +extern "C" void vtk_algorithm_release_data_flag_off(vtkAlgorithm* sself) { sself->ReleaseDataFlagOff(); } +extern "C" int vtk_algorithm_get_update_piece(vtkAlgorithm* sself) { return sself->GetUpdatePiece(); } +extern "C" int vtk_algorithm_get_update_number_of_pieces(vtkAlgorithm* sself) { return sself->GetUpdateNumberOfPieces(); } +extern "C" int vtk_algorithm_get_update_ghost_level(vtkAlgorithm* sself) { return sself->GetUpdateGhostLevel(); } +extern "C" vtkAlgorithmOutput * vtkAlgorithmOutput_new () {return vtkAlgorithmOutput :: New () ;} +extern "C" void vtkAlgorithmOutput_destructor (vtkAlgorithmOutput * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_algorithm_output_set_index(vtkAlgorithmOutput* sself, int index) { sself->SetIndex(index); } +extern "C" int vtk_algorithm_output_get_index(vtkAlgorithmOutput* sself) { return sself->GetIndex(); } +extern "C" vtkAnnotationLayersAlgorithm * vtkAnnotationLayersAlgorithm_new () {return vtkAnnotationLayersAlgorithm :: New () ;} +extern "C" void vtkAnnotationLayersAlgorithm_destructor (vtkAnnotationLayersAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkArrayDataAlgorithm * vtkArrayDataAlgorithm_new () {return vtkArrayDataAlgorithm :: New () ;} +extern "C" void vtkArrayDataAlgorithm_destructor (vtkArrayDataAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkCachedStreamingDemandDrivenPipeline * vtkCachedStreamingDemandDrivenPipeline_new () {return vtkCachedStreamingDemandDrivenPipeline :: New () ;} +extern "C" void vtkCachedStreamingDemandDrivenPipeline_destructor (vtkCachedStreamingDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cached_streaming_demand_driven_pipeline_set_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself, int size) { sself->SetCacheSize(size); } +extern "C" int vtk_cached_streaming_demand_driven_pipeline_get_cache_size(vtkCachedStreamingDemandDrivenPipeline* sself) { return sself->GetCacheSize(); } +extern "C" vtkCastToConcrete * vtkCastToConcrete_new () {return vtkCastToConcrete :: New () ;} +extern "C" void vtkCastToConcrete_destructor (vtkCastToConcrete * sself) {sself -> Delete () ; return ;} +extern "C" vtkCompositeDataPipeline * vtkCompositeDataPipeline_new () {return vtkCompositeDataPipeline :: New () ;} +extern "C" void vtkCompositeDataPipeline_destructor (vtkCompositeDataPipeline * sself) {sself -> Delete () ; return ;} +extern "C" vtkCompositeDataSetAlgorithm * vtkCompositeDataSetAlgorithm_new () {return vtkCompositeDataSetAlgorithm :: New () ;} +extern "C" void vtkCompositeDataSetAlgorithm_destructor (vtkCompositeDataSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkDataObjectAlgorithm * vtkDataObjectAlgorithm_new () {return vtkDataObjectAlgorithm :: New () ;} +extern "C" void vtkDataObjectAlgorithm_destructor (vtkDataObjectAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkDataSetAlgorithm * vtkDataSetAlgorithm_new () {return vtkDataSetAlgorithm :: New () ;} +extern "C" void vtkDataSetAlgorithm_destructor (vtkDataSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkDemandDrivenPipeline * vtkDemandDrivenPipeline_new () {return vtkDemandDrivenPipeline :: New () ;} +extern "C" void vtkDemandDrivenPipeline_destructor (vtkDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_demand_driven_pipeline_get_pipeline_m_time(vtkDemandDrivenPipeline* sself) { return sself->GetPipelineMTime(); } +extern "C" int vtk_demand_driven_pipeline_set_release_data_flag(vtkDemandDrivenPipeline* sself, int port, int n) { return sself->SetReleaseDataFlag(port, n); } +extern "C" int vtk_demand_driven_pipeline_get_release_data_flag(vtkDemandDrivenPipeline* sself, int port) { return sself->GetReleaseDataFlag(port); } +extern "C" int vtk_demand_driven_pipeline_update_pipeline_m_time(vtkDemandDrivenPipeline* sself) { return sself->UpdatePipelineMTime(); } +extern "C" int vtk_demand_driven_pipeline_update_data_object(vtkDemandDrivenPipeline* sself) { return sself->UpdateDataObject(); } +extern "C" int vtk_demand_driven_pipeline_update_data(vtkDemandDrivenPipeline* sself, int outputPort) { return sself->UpdateData(outputPort); } +extern "C" vtkDirectedGraphAlgorithm * vtkDirectedGraphAlgorithm_new () {return vtkDirectedGraphAlgorithm :: New () ;} +extern "C" void vtkDirectedGraphAlgorithm_destructor (vtkDirectedGraphAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkEnsembleSource * vtkEnsembleSource_new () {return vtkEnsembleSource :: New () ;} +extern "C" void vtkEnsembleSource_destructor (vtkEnsembleSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_ensemble_source_remove_all_members(vtkEnsembleSource* sself) { sself->RemoveAllMembers(); } +extern "C" unsigned int vtk_ensemble_source_get_number_of_members(vtkEnsembleSource* sself) { return sself->GetNumberOfMembers(); } +extern "C" void vtk_ensemble_source_set_current_member(vtkEnsembleSource* sself, unsigned int _arg) { sself->SetCurrentMember(_arg); } +extern "C" unsigned int vtk_ensemble_source_get_current_member(vtkEnsembleSource* sself) { return sself->GetCurrentMember(); } +extern "C" vtkExplicitStructuredGridAlgorithm * vtkExplicitStructuredGridAlgorithm_new () {return vtkExplicitStructuredGridAlgorithm :: New () ;} +extern "C" void vtkExplicitStructuredGridAlgorithm_destructor (vtkExplicitStructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkExtentRCBPartitioner * vtkExtentRCBPartitioner_new () {return vtkExtentRCBPartitioner :: New () ;} +extern "C" void vtkExtentRCBPartitioner_destructor (vtkExtentRCBPartitioner * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_extent_rcb_partitioner_set_number_of_partitions(vtkExtentRCBPartitioner* sself, const int N) { sself->SetNumberOfPartitions(N); } +extern "C" void vtk_extent_rcb_partitioner_set_global_extent(vtkExtentRCBPartitioner* sself, int imin, int imax, int jmin, int jmax, int kmin, int kmax) { sself->SetGlobalExtent(imin, imax, jmin, jmax, kmin, kmax); } +extern "C" void vtk_extent_rcb_partitioner_set_duplicate_nodes(vtkExtentRCBPartitioner* sself, int _arg) { sself->SetDuplicateNodes(_arg); } +extern "C" int vtk_extent_rcb_partitioner_get_duplicate_nodes(vtkExtentRCBPartitioner* sself) { return sself->GetDuplicateNodes(); } +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_on(vtkExtentRCBPartitioner* sself) { sself->DuplicateNodesOn(); } +extern "C" void vtk_extent_rcb_partitioner_duplicate_nodes_off(vtkExtentRCBPartitioner* sself) { sself->DuplicateNodesOff(); } +extern "C" void vtk_extent_rcb_partitioner_set_number_of_ghost_layers(vtkExtentRCBPartitioner* sself, int _arg) { sself->SetNumberOfGhostLayers(_arg); } +extern "C" int vtk_extent_rcb_partitioner_get_number_of_ghost_layers(vtkExtentRCBPartitioner* sself) { return sself->GetNumberOfGhostLayers(); } +extern "C" int vtk_extent_rcb_partitioner_get_num_extents(vtkExtentRCBPartitioner* sself) { return sself->GetNumExtents(); } +extern "C" void vtk_extent_rcb_partitioner_partition(vtkExtentRCBPartitioner* sself) { sself->Partition(); } +extern "C" vtkExtentSplitter * vtkExtentSplitter_new () {return vtkExtentSplitter :: New () ;} +extern "C" void vtkExtentSplitter_destructor (vtkExtentSplitter * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_extent_splitter_add_extent_source(vtkExtentSplitter* sself, int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtentSource(id, priority, x0, x1, y0, y1, z0, z1); } +extern "C" void vtk_extent_splitter_remove_extent_source(vtkExtentSplitter* sself, int id) { sself->RemoveExtentSource(id); } +extern "C" void vtk_extent_splitter_remove_all_extent_sources(vtkExtentSplitter* sself) { sself->RemoveAllExtentSources(); } +extern "C" void vtk_extent_splitter_add_extent(vtkExtentSplitter* sself, int x0, int x1, int y0, int y1, int z0, int z1) { sself->AddExtent(x0, x1, y0, y1, z0, z1); } +extern "C" int vtk_extent_splitter_compute_sub_extents(vtkExtentSplitter* sself) { return sself->ComputeSubExtents(); } +extern "C" int vtk_extent_splitter_get_number_of_sub_extents(vtkExtentSplitter* sself) { return sself->GetNumberOfSubExtents(); } +extern "C" int vtk_extent_splitter_get_sub_extent_source(vtkExtentSplitter* sself, int index) { return sself->GetSubExtentSource(index); } +extern "C" int vtk_extent_splitter_get_point_mode(vtkExtentSplitter* sself) { return sself->GetPointMode(); } +extern "C" void vtk_extent_splitter_set_point_mode(vtkExtentSplitter* sself, int _arg) { sself->SetPointMode(_arg); } +extern "C" void vtk_extent_splitter_point_mode_on(vtkExtentSplitter* sself) { sself->PointModeOn(); } +extern "C" void vtk_extent_splitter_point_mode_off(vtkExtentSplitter* sself) { sself->PointModeOff(); } +extern "C" vtkExtentTranslator * vtkExtentTranslator_new () {return vtkExtentTranslator :: New () ;} +extern "C" void vtkExtentTranslator_destructor (vtkExtentTranslator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_extent_translator_set_whole_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extent_translator_set_extent(vtkExtentTranslator* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_extent_translator_set_piece(vtkExtentTranslator* sself, int _arg) { sself->SetPiece(_arg); } +extern "C" int vtk_extent_translator_get_piece(vtkExtentTranslator* sself) { return sself->GetPiece(); } +extern "C" void vtk_extent_translator_set_number_of_pieces(vtkExtentTranslator* sself, int _arg) { sself->SetNumberOfPieces(_arg); } +extern "C" int vtk_extent_translator_get_number_of_pieces(vtkExtentTranslator* sself) { return sself->GetNumberOfPieces(); } +extern "C" void vtk_extent_translator_set_ghost_level(vtkExtentTranslator* sself, int _arg) { sself->SetGhostLevel(_arg); } +extern "C" int vtk_extent_translator_get_ghost_level(vtkExtentTranslator* sself) { return sself->GetGhostLevel(); } +extern "C" int vtk_extent_translator_piece_to_extent(vtkExtentTranslator* sself) { return sself->PieceToExtent(); } +extern "C" int vtk_extent_translator_piece_to_extent_by_points(vtkExtentTranslator* sself) { return sself->PieceToExtentByPoints(); } +extern "C" void vtk_extent_translator_set_split_mode_to_block(vtkExtentTranslator* sself) { sself->SetSplitModeToBlock(); } +extern "C" void vtk_extent_translator_set_split_mode_to_x_slab(vtkExtentTranslator* sself) { sself->SetSplitModeToXSlab(); } +extern "C" void vtk_extent_translator_set_split_mode_to_y_slab(vtkExtentTranslator* sself) { sself->SetSplitModeToYSlab(); } +extern "C" void vtk_extent_translator_set_split_mode_to_z_slab(vtkExtentTranslator* sself) { sself->SetSplitModeToZSlab(); } +extern "C" int vtk_extent_translator_get_split_mode(vtkExtentTranslator* sself) { return sself->GetSplitMode(); } +extern "C" vtkGraphAlgorithm * vtkGraphAlgorithm_new () {return vtkGraphAlgorithm :: New () ;} +extern "C" void vtkGraphAlgorithm_destructor (vtkGraphAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkHierarchicalBoxDataSetAlgorithm * vtkHierarchicalBoxDataSetAlgorithm_new () {return vtkHierarchicalBoxDataSetAlgorithm :: New () ;} +extern "C" void vtkHierarchicalBoxDataSetAlgorithm_destructor (vtkHierarchicalBoxDataSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkImageToStructuredGrid * vtkImageToStructuredGrid_new () {return vtkImageToStructuredGrid :: New () ;} +extern "C" void vtkImageToStructuredGrid_destructor (vtkImageToStructuredGrid * sself) {sself -> Delete () ; return ;} +extern "C" vtkImageToStructuredPoints * vtkImageToStructuredPoints_new () {return vtkImageToStructuredPoints :: New () ;} +extern "C" void vtkImageToStructuredPoints_destructor (vtkImageToStructuredPoints * sself) {sself -> Delete () ; return ;} +extern "C" vtkMoleculeAlgorithm * vtkMoleculeAlgorithm_new () {return vtkMoleculeAlgorithm :: New () ;} +extern "C" void vtkMoleculeAlgorithm_destructor (vtkMoleculeAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkMultiBlockDataSetAlgorithm * vtkMultiBlockDataSetAlgorithm_new () {return vtkMultiBlockDataSetAlgorithm :: New () ;} +extern "C" void vtkMultiBlockDataSetAlgorithm_destructor (vtkMultiBlockDataSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkMultiTimeStepAlgorithm * vtkMultiTimeStepAlgorithm_new () {return vtkMultiTimeStepAlgorithm :: New () ;} +extern "C" void vtkMultiTimeStepAlgorithm_destructor (vtkMultiTimeStepAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkNonOverlappingAMRAlgorithm * vtkNonOverlappingAMRAlgorithm_new () {return vtkNonOverlappingAMRAlgorithm :: New () ;} +extern "C" void vtkNonOverlappingAMRAlgorithm_destructor (vtkNonOverlappingAMRAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkOverlappingAMRAlgorithm * vtkOverlappingAMRAlgorithm_new () {return vtkOverlappingAMRAlgorithm :: New () ;} +extern "C" void vtkOverlappingAMRAlgorithm_destructor (vtkOverlappingAMRAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkPassInputTypeAlgorithm * vtkPassInputTypeAlgorithm_new () {return vtkPassInputTypeAlgorithm :: New () ;} +extern "C" void vtkPassInputTypeAlgorithm_destructor (vtkPassInputTypeAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkPiecewiseFunctionAlgorithm * vtkPiecewiseFunctionAlgorithm_new () {return vtkPiecewiseFunctionAlgorithm :: New () ;} +extern "C" void vtkPiecewiseFunctionAlgorithm_destructor (vtkPiecewiseFunctionAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkPiecewiseFunctionShiftScale * vtkPiecewiseFunctionShiftScale_new () {return vtkPiecewiseFunctionShiftScale :: New () ;} +extern "C" void vtkPiecewiseFunctionShiftScale_destructor (vtkPiecewiseFunctionShiftScale * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_piecewise_function_shift_scale_set_position_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetPositionShift(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_position_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetPositionScale(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_value_shift(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetValueShift(_arg); } +extern "C" void vtk_piecewise_function_shift_scale_set_value_scale(vtkPiecewiseFunctionShiftScale* sself, double _arg) { sself->SetValueScale(_arg); } +extern "C" double vtk_piecewise_function_shift_scale_get_position_shift(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetPositionShift(); } +extern "C" double vtk_piecewise_function_shift_scale_get_position_scale(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetPositionScale(); } +extern "C" double vtk_piecewise_function_shift_scale_get_value_shift(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetValueShift(); } +extern "C" double vtk_piecewise_function_shift_scale_get_value_scale(vtkPiecewiseFunctionShiftScale* sself) { return sself->GetValueScale(); } +extern "C" vtkPointSetAlgorithm * vtkPointSetAlgorithm_new () {return vtkPointSetAlgorithm :: New () ;} +extern "C" void vtkPointSetAlgorithm_destructor (vtkPointSetAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkPolyDataAlgorithm * vtkPolyDataAlgorithm_new () {return vtkPolyDataAlgorithm :: New () ;} +extern "C" void vtkPolyDataAlgorithm_destructor (vtkPolyDataAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkProgressObserver * vtkProgressObserver_new () {return vtkProgressObserver :: New () ;} +extern "C" void vtkProgressObserver_destructor (vtkProgressObserver * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_progress_observer_update_progress(vtkProgressObserver* sself, double amount) { sself->UpdateProgress(amount); } +extern "C" double vtk_progress_observer_get_progress(vtkProgressObserver* sself) { return sself->GetProgress(); } +extern "C" vtkReaderExecutive * vtkReaderExecutive_new () {return vtkReaderExecutive :: New () ;} +extern "C" void vtkReaderExecutive_destructor (vtkReaderExecutive * sself) {sself -> Delete () ; return ;} +extern "C" vtkRectilinearGridAlgorithm * vtkRectilinearGridAlgorithm_new () {return vtkRectilinearGridAlgorithm :: New () ;} +extern "C" void vtkRectilinearGridAlgorithm_destructor (vtkRectilinearGridAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkSMPProgressObserver * vtkSMPProgressObserver_new () {return vtkSMPProgressObserver :: New () ;} +extern "C" void vtkSMPProgressObserver_destructor (vtkSMPProgressObserver * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_smp_progress_observer_update_progress(vtkSMPProgressObserver* sself, double progress) { sself->UpdateProgress(progress); } +extern "C" vtkSelectionAlgorithm * vtkSelectionAlgorithm_new () {return vtkSelectionAlgorithm :: New () ;} +extern "C" void vtkSelectionAlgorithm_destructor (vtkSelectionAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkSimpleScalarTree * vtkSimpleScalarTree_new () {return vtkSimpleScalarTree :: New () ;} +extern "C" void vtkSimpleScalarTree_destructor (vtkSimpleScalarTree * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_simple_scalar_tree_set_branching_factor(vtkSimpleScalarTree* sself, int _arg) { sself->SetBranchingFactor(_arg); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor_min_value(vtkSimpleScalarTree* sself) { return sself->GetBranchingFactorMinValue(); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor_max_value(vtkSimpleScalarTree* sself) { return sself->GetBranchingFactorMaxValue(); } +extern "C" int vtk_simple_scalar_tree_get_branching_factor(vtkSimpleScalarTree* sself) { return sself->GetBranchingFactor(); } +extern "C" int vtk_simple_scalar_tree_get_level(vtkSimpleScalarTree* sself) { return sself->GetLevel(); } +extern "C" void vtk_simple_scalar_tree_set_max_level(vtkSimpleScalarTree* sself, int _arg) { sself->SetMaxLevel(_arg); } +extern "C" int vtk_simple_scalar_tree_get_max_level_min_value(vtkSimpleScalarTree* sself) { return sself->GetMaxLevelMinValue(); } +extern "C" int vtk_simple_scalar_tree_get_max_level_max_value(vtkSimpleScalarTree* sself) { return sself->GetMaxLevelMaxValue(); } +extern "C" int vtk_simple_scalar_tree_get_max_level(vtkSimpleScalarTree* sself) { return sself->GetMaxLevel(); } +extern "C" void vtk_simple_scalar_tree_build_tree(vtkSimpleScalarTree* sself) { sself->BuildTree(); } +extern "C" void vtk_simple_scalar_tree_initialize(vtkSimpleScalarTree* sself) { sself->Initialize(); } +extern "C" void vtk_simple_scalar_tree_init_traversal(vtkSimpleScalarTree* sself, double scalarValue) { sself->InitTraversal(scalarValue); } +extern "C" long long vtk_simple_scalar_tree_get_number_of_cell_batches(vtkSimpleScalarTree* sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } +extern "C" vtkSpanSpace * vtkSpanSpace_new () {return vtkSpanSpace :: New () ;} +extern "C" void vtkSpanSpace_destructor (vtkSpanSpace * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_span_space_set_scalar_range(vtkSpanSpace* sself, double _arg1, double _arg2) { sself->SetScalarRange(_arg1, _arg2); } +extern "C" void vtk_span_space_set_compute_scalar_range(vtkSpanSpace* sself, int _arg) { sself->SetComputeScalarRange(_arg); } +extern "C" int vtk_span_space_get_compute_scalar_range(vtkSpanSpace* sself) { return sself->GetComputeScalarRange(); } +extern "C" void vtk_span_space_compute_scalar_range_on(vtkSpanSpace* sself) { sself->ComputeScalarRangeOn(); } +extern "C" void vtk_span_space_compute_scalar_range_off(vtkSpanSpace* sself) { sself->ComputeScalarRangeOff(); } +extern "C" void vtk_span_space_set_resolution(vtkSpanSpace* sself, long long _arg) { sself->SetResolution(_arg); } +extern "C" long long vtk_span_space_get_resolution_min_value(vtkSpanSpace* sself) { return sself->GetResolutionMinValue(); } +extern "C" long long vtk_span_space_get_resolution_max_value(vtkSpanSpace* sself) { return sself->GetResolutionMaxValue(); } +extern "C" long long vtk_span_space_get_resolution(vtkSpanSpace* sself) { return sself->GetResolution(); } +extern "C" void vtk_span_space_set_compute_resolution(vtkSpanSpace* sself, int _arg) { sself->SetComputeResolution(_arg); } +extern "C" int vtk_span_space_get_compute_resolution(vtkSpanSpace* sself) { return sself->GetComputeResolution(); } +extern "C" void vtk_span_space_compute_resolution_on(vtkSpanSpace* sself) { sself->ComputeResolutionOn(); } +extern "C" void vtk_span_space_compute_resolution_off(vtkSpanSpace* sself) { sself->ComputeResolutionOff(); } +extern "C" void vtk_span_space_set_number_of_cells_per_bucket(vtkSpanSpace* sself, int _arg) { sself->SetNumberOfCellsPerBucket(_arg); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_min_value(vtkSpanSpace* sself) { return sself->GetNumberOfCellsPerBucketMinValue(); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket_max_value(vtkSpanSpace* sself) { return sself->GetNumberOfCellsPerBucketMaxValue(); } +extern "C" int vtk_span_space_get_number_of_cells_per_bucket(vtkSpanSpace* sself) { return sself->GetNumberOfCellsPerBucket(); } +extern "C" void vtk_span_space_initialize(vtkSpanSpace* sself) { sself->Initialize(); } +extern "C" void vtk_span_space_build_tree(vtkSpanSpace* sself) { sself->BuildTree(); } +extern "C" void vtk_span_space_init_traversal(vtkSpanSpace* sself, double scalarValue) { sself->InitTraversal(scalarValue); } +extern "C" long long vtk_span_space_get_number_of_cell_batches(vtkSpanSpace* sself, double scalarValue) { return sself->GetNumberOfCellBatches(scalarValue); } +extern "C" void vtk_span_space_set_batch_size(vtkSpanSpace* sself, long long _arg) { sself->SetBatchSize(_arg); } +extern "C" long long vtk_span_space_get_batch_size_min_value(vtkSpanSpace* sself) { return sself->GetBatchSizeMinValue(); } +extern "C" long long vtk_span_space_get_batch_size_max_value(vtkSpanSpace* sself) { return sself->GetBatchSizeMaxValue(); } +extern "C" long long vtk_span_space_get_batch_size(vtkSpanSpace* sself) { return sself->GetBatchSize(); } +extern "C" vtkSphereTree * vtkSphereTree_new () {return vtkSphereTree :: New () ;} +extern "C" void vtkSphereTree_destructor (vtkSphereTree * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_sphere_tree_build(vtkSphereTree* sself) { sself->Build(); } +extern "C" void vtk_sphere_tree_set_build_hierarchy(vtkSphereTree* sself, bool _arg) { sself->SetBuildHierarchy(_arg); } +extern "C" bool vtk_sphere_tree_get_build_hierarchy(vtkSphereTree* sself) { return sself->GetBuildHierarchy(); } +extern "C" void vtk_sphere_tree_build_hierarchy_on(vtkSphereTree* sself) { sself->BuildHierarchyOn(); } +extern "C" void vtk_sphere_tree_build_hierarchy_off(vtkSphereTree* sself) { sself->BuildHierarchyOff(); } +extern "C" void vtk_sphere_tree_set_resolution(vtkSphereTree* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_sphere_tree_get_resolution_min_value(vtkSphereTree* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_sphere_tree_get_resolution_max_value(vtkSphereTree* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_sphere_tree_get_resolution(vtkSphereTree* sself) { return sself->GetResolution(); } +extern "C" void vtk_sphere_tree_set_max_level(vtkSphereTree* sself, int _arg) { sself->SetMaxLevel(_arg); } +extern "C" int vtk_sphere_tree_get_max_level_min_value(vtkSphereTree* sself) { return sself->GetMaxLevelMinValue(); } +extern "C" int vtk_sphere_tree_get_max_level_max_value(vtkSphereTree* sself) { return sself->GetMaxLevelMaxValue(); } +extern "C" int vtk_sphere_tree_get_max_level(vtkSphereTree* sself) { return sself->GetMaxLevel(); } +extern "C" int vtk_sphere_tree_get_number_of_levels(vtkSphereTree* sself) { return sself->GetNumberOfLevels(); } +extern "C" vtkStreamingDemandDrivenPipeline * vtkStreamingDemandDrivenPipeline_new () {return vtkStreamingDemandDrivenPipeline :: New () ;} +extern "C" void vtkStreamingDemandDrivenPipeline_destructor (vtkStreamingDemandDrivenPipeline * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_streaming_demand_driven_pipeline_update(vtkStreamingDemandDrivenPipeline* sself) { return sself->Update(); } +extern "C" int vtk_streaming_demand_driven_pipeline_update_whole_extent(vtkStreamingDemandDrivenPipeline* sself) { return sself->UpdateWholeExtent(); } +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_update_extent(vtkStreamingDemandDrivenPipeline* sself, int outputPort) { return sself->PropagateUpdateExtent(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_propagate_time(vtkStreamingDemandDrivenPipeline* sself, int outputPort) { return sself->PropagateTime(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_update_time_dependent_information(vtkStreamingDemandDrivenPipeline* sself, int outputPort) { return sself->UpdateTimeDependentInformation(outputPort); } +extern "C" int vtk_streaming_demand_driven_pipeline_set_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port, int flag) { return sself->SetRequestExactExtent(port, flag); } +extern "C" int vtk_streaming_demand_driven_pipeline_get_request_exact_extent(vtkStreamingDemandDrivenPipeline* sself, int port) { return sself->GetRequestExactExtent(port); } +extern "C" vtkStructuredGridAlgorithm * vtkStructuredGridAlgorithm_new () {return vtkStructuredGridAlgorithm :: New () ;} +extern "C" void vtkStructuredGridAlgorithm_destructor (vtkStructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkTableAlgorithm * vtkTableAlgorithm_new () {return vtkTableAlgorithm :: New () ;} +extern "C" void vtkTableAlgorithm_destructor (vtkTableAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkThreadedCompositeDataPipeline * vtkThreadedCompositeDataPipeline_new () {return vtkThreadedCompositeDataPipeline :: New () ;} +extern "C" void vtkThreadedCompositeDataPipeline_destructor (vtkThreadedCompositeDataPipeline * sself) {sself -> Delete () ; return ;} +extern "C" vtkTreeAlgorithm * vtkTreeAlgorithm_new () {return vtkTreeAlgorithm :: New () ;} +extern "C" void vtkTreeAlgorithm_destructor (vtkTreeAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkTrivialConsumer * vtkTrivialConsumer_new () {return vtkTrivialConsumer :: New () ;} +extern "C" void vtkTrivialConsumer_destructor (vtkTrivialConsumer * sself) {sself -> Delete () ; return ;} +extern "C" vtkTrivialProducer * vtkTrivialProducer_new () {return vtkTrivialProducer :: New () ;} +extern "C" void vtkTrivialProducer_destructor (vtkTrivialProducer * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_trivial_producer_get_m_time(vtkTrivialProducer* sself) { return sself->GetMTime(); } +extern "C" void vtk_trivial_producer_set_whole_extent(vtkTrivialProducer* sself, int _arg1, int _arg2, int _arg3, int _arg4, int _arg5, int _arg6) { sself->SetWholeExtent(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" vtkUndirectedGraphAlgorithm * vtkUndirectedGraphAlgorithm_new () {return vtkUndirectedGraphAlgorithm :: New () ;} +extern "C" void vtkUndirectedGraphAlgorithm_destructor (vtkUndirectedGraphAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkUniformGridAMRAlgorithm * vtkUniformGridAMRAlgorithm_new () {return vtkUniformGridAMRAlgorithm :: New () ;} +extern "C" void vtkUniformGridAMRAlgorithm_destructor (vtkUniformGridAMRAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkUniformGridPartitioner * vtkUniformGridPartitioner_new () {return vtkUniformGridPartitioner :: New () ;} +extern "C" void vtkUniformGridPartitioner_destructor (vtkUniformGridPartitioner * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_uniform_grid_partitioner_get_number_of_partitions(vtkUniformGridPartitioner* sself) { return sself->GetNumberOfPartitions(); } +extern "C" void vtk_uniform_grid_partitioner_set_number_of_partitions(vtkUniformGridPartitioner* sself, int _arg) { sself->SetNumberOfPartitions(_arg); } +extern "C" int vtk_uniform_grid_partitioner_get_number_of_ghost_layers(vtkUniformGridPartitioner* sself) { return sself->GetNumberOfGhostLayers(); } +extern "C" void vtk_uniform_grid_partitioner_set_number_of_ghost_layers(vtkUniformGridPartitioner* sself, int _arg) { sself->SetNumberOfGhostLayers(_arg); } +extern "C" int vtk_uniform_grid_partitioner_get_duplicate_nodes(vtkUniformGridPartitioner* sself) { return sself->GetDuplicateNodes(); } +extern "C" void vtk_uniform_grid_partitioner_set_duplicate_nodes(vtkUniformGridPartitioner* sself, int _arg) { sself->SetDuplicateNodes(_arg); } +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_on(vtkUniformGridPartitioner* sself) { sself->DuplicateNodesOn(); } +extern "C" void vtk_uniform_grid_partitioner_duplicate_nodes_off(vtkUniformGridPartitioner* sself) { sself->DuplicateNodesOff(); } +extern "C" vtkUnstructuredGridAlgorithm * vtkUnstructuredGridAlgorithm_new () {return vtkUnstructuredGridAlgorithm :: New () ;} +extern "C" void vtkUnstructuredGridAlgorithm_destructor (vtkUnstructuredGridAlgorithm * sself) {sself -> Delete () ; return ;} +extern "C" vtkUnstructuredGridBaseAlgorithm * vtkUnstructuredGridBaseAlgorithm_new () {return vtkUnstructuredGridBaseAlgorithm :: New () ;} +extern "C" void vtkUnstructuredGridBaseAlgorithm_destructor (vtkUnstructuredGridBaseAlgorithm * sself) {sself -> Delete () ; return ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp index 1d8e7f9..c1e7245 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_math.cpp @@ -23,30 +23,81 @@ #include // Implement declared functions -extern "C" vtkNew < vtkAmoebaMinimizer > vtkAmoebaMinimizer_new () {return vtkNew < vtkAmoebaMinimizer > () ;} -extern "C" void vtkAmoebaMinimizer_destructor (vtkNew < vtkAmoebaMinimizer > sself) {sself . Reset () ; return ;} -extern "C" void * vtkAmoebaMinimizer_get_ptr (vtkNew < vtkAmoebaMinimizer > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkFFT > vtkFFT_new () {return vtkNew < vtkFFT > () ;} -extern "C" void vtkFFT_destructor (vtkNew < vtkFFT > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFFT_get_ptr (vtkNew < vtkFFT > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMatrix3x3 > vtkMatrix3x3_new () {return vtkNew < vtkMatrix3x3 > () ;} -extern "C" void vtkMatrix3x3_destructor (vtkNew < vtkMatrix3x3 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMatrix3x3_get_ptr (vtkNew < vtkMatrix3x3 > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMatrix4x4 > vtkMatrix4x4_new () {return vtkNew < vtkMatrix4x4 > () ;} -extern "C" void vtkMatrix4x4_destructor (vtkNew < vtkMatrix4x4 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMatrix4x4_get_ptr (vtkNew < vtkMatrix4x4 > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPolynomialSolversUnivariate > vtkPolynomialSolversUnivariate_new () {return vtkNew < vtkPolynomialSolversUnivariate > () ;} -extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkNew < vtkPolynomialSolversUnivariate > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPolynomialSolversUnivariate_get_ptr (vtkNew < vtkPolynomialSolversUnivariate > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkQuaternionInterpolator > vtkQuaternionInterpolator_new () {return vtkNew < vtkQuaternionInterpolator > () ;} -extern "C" void vtkQuaternionInterpolator_destructor (vtkNew < vtkQuaternionInterpolator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkQuaternionInterpolator_get_ptr (vtkNew < vtkQuaternionInterpolator > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkRungeKutta2 > vtkRungeKutta2_new () {return vtkNew < vtkRungeKutta2 > () ;} -extern "C" void vtkRungeKutta2_destructor (vtkNew < vtkRungeKutta2 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRungeKutta2_get_ptr (vtkNew < vtkRungeKutta2 > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkRungeKutta4 > vtkRungeKutta4_new () {return vtkNew < vtkRungeKutta4 > () ;} -extern "C" void vtkRungeKutta4_destructor (vtkNew < vtkRungeKutta4 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRungeKutta4_get_ptr (vtkNew < vtkRungeKutta4 > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkRungeKutta45 > vtkRungeKutta45_new () {return vtkNew < vtkRungeKutta45 > () ;} -extern "C" void vtkRungeKutta45_destructor (vtkNew < vtkRungeKutta45 > sself) {sself . Reset () ; return ;} -extern "C" void * vtkRungeKutta45_get_ptr (vtkNew < vtkRungeKutta45 > sself) {return sself . GetPointer () ;} +extern "C" vtkAmoebaMinimizer * vtkAmoebaMinimizer_new () {return vtkAmoebaMinimizer :: New () ;} +extern "C" void vtkAmoebaMinimizer_destructor (vtkAmoebaMinimizer * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_amoeba_minimizer_set_parameter_value(vtkAmoebaMinimizer* sself, const char* name, double value) { sself->SetParameterValue(name, value); } +extern "C" void vtk_amoeba_minimizer_set_parameter_scale(vtkAmoebaMinimizer* sself, const char* name, double scale) { sself->SetParameterScale(name, scale); } +extern "C" double vtk_amoeba_minimizer_get_parameter_scale(vtkAmoebaMinimizer* sself, const char* name) { return sself->GetParameterScale(name); } +extern "C" double vtk_amoeba_minimizer_get_parameter_value(vtkAmoebaMinimizer* sself, const char* name) { return sself->GetParameterValue(name); } +extern "C" const char* vtk_amoeba_minimizer_get_parameter_name(vtkAmoebaMinimizer* sself, int i) { return sself->GetParameterName(i); } +extern "C" int vtk_amoeba_minimizer_get_number_of_parameters(vtkAmoebaMinimizer* sself) { return sself->GetNumberOfParameters(); } +extern "C" void vtk_amoeba_minimizer_initialize(vtkAmoebaMinimizer* sself) { sself->Initialize(); } +extern "C" void vtk_amoeba_minimizer_minimize(vtkAmoebaMinimizer* sself) { sself->Minimize(); } +extern "C" int vtk_amoeba_minimizer_iterate(vtkAmoebaMinimizer* sself) { return sself->Iterate(); } +extern "C" void vtk_amoeba_minimizer_set_function_value(vtkAmoebaMinimizer* sself, double _arg) { sself->SetFunctionValue(_arg); } +extern "C" double vtk_amoeba_minimizer_get_function_value(vtkAmoebaMinimizer* sself) { return sself->GetFunctionValue(); } +extern "C" void vtk_amoeba_minimizer_set_contraction_ratio(vtkAmoebaMinimizer* sself, double _arg) { sself->SetContractionRatio(_arg); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_min_value(vtkAmoebaMinimizer* sself) { return sself->GetContractionRatioMinValue(); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio_max_value(vtkAmoebaMinimizer* sself) { return sself->GetContractionRatioMaxValue(); } +extern "C" double vtk_amoeba_minimizer_get_contraction_ratio(vtkAmoebaMinimizer* sself) { return sself->GetContractionRatio(); } +extern "C" void vtk_amoeba_minimizer_set_expansion_ratio(vtkAmoebaMinimizer* sself, double _arg) { sself->SetExpansionRatio(_arg); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_min_value(vtkAmoebaMinimizer* sself) { return sself->GetExpansionRatioMinValue(); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio_max_value(vtkAmoebaMinimizer* sself) { return sself->GetExpansionRatioMaxValue(); } +extern "C" double vtk_amoeba_minimizer_get_expansion_ratio(vtkAmoebaMinimizer* sself) { return sself->GetExpansionRatio(); } +extern "C" void vtk_amoeba_minimizer_set_tolerance(vtkAmoebaMinimizer* sself, double _arg) { sself->SetTolerance(_arg); } +extern "C" double vtk_amoeba_minimizer_get_tolerance(vtkAmoebaMinimizer* sself) { return sself->GetTolerance(); } +extern "C" void vtk_amoeba_minimizer_set_parameter_tolerance(vtkAmoebaMinimizer* sself, double _arg) { sself->SetParameterTolerance(_arg); } +extern "C" double vtk_amoeba_minimizer_get_parameter_tolerance(vtkAmoebaMinimizer* sself) { return sself->GetParameterTolerance(); } +extern "C" void vtk_amoeba_minimizer_set_max_iterations(vtkAmoebaMinimizer* sself, int _arg) { sself->SetMaxIterations(_arg); } +extern "C" int vtk_amoeba_minimizer_get_max_iterations(vtkAmoebaMinimizer* sself) { return sself->GetMaxIterations(); } +extern "C" int vtk_amoeba_minimizer_get_iterations(vtkAmoebaMinimizer* sself) { return sself->GetIterations(); } +extern "C" int vtk_amoeba_minimizer_get_function_evaluations(vtkAmoebaMinimizer* sself) { return sself->GetFunctionEvaluations(); } +extern "C" void vtk_amoeba_minimizer_evaluate_function(vtkAmoebaMinimizer* sself) { sself->EvaluateFunction(); } +extern "C" vtkFFT * vtkFFT_new () {return vtkFFT :: New () ;} +extern "C" void vtkFFT_destructor (vtkFFT * sself) {sself -> Delete () ; return ;} +extern "C" double vtk_fft_hanning_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->HanningGenerator(x, size); } +extern "C" double vtk_fft_bartlett_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->BartlettGenerator(x, size); } +extern "C" double vtk_fft_sine_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->SineGenerator(x, size); } +extern "C" double vtk_fft_blackman_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->BlackmanGenerator(x, size); } +extern "C" double vtk_fft_rectangular_generator(vtkFFT* sself, const size_t x, const size_t size) { return sself->RectangularGenerator(x, size); } +extern "C" vtkMatrix3x3 * vtkMatrix3x3_new () {return vtkMatrix3x3 :: New () ;} +extern "C" void vtkMatrix3x3_destructor (vtkMatrix3x3 * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_matrix_3_x_3_zero(vtkMatrix3x3* sself) { sself->Zero(); } +extern "C" void vtk_matrix_3_x_3_identity(vtkMatrix3x3* sself) { sself->Identity(); } +extern "C" double vtk_matrix_3_x_3_determinant(vtkMatrix3x3* sself) { return sself->Determinant(); } +extern "C" void vtk_matrix_3_x_3_set_element(vtkMatrix3x3* sself, int i, int j, double value) { sself->SetElement(i, j, value); } +extern "C" double vtk_matrix_3_x_3_get_element(vtkMatrix3x3* sself, int i, int j) { return sself->GetElement(i, j); } +extern "C" bool vtk_matrix_3_x_3_is_identity(vtkMatrix3x3* sself) { return sself->IsIdentity(); } +extern "C" vtkMatrix4x4 * vtkMatrix4x4_new () {return vtkMatrix4x4 :: New () ;} +extern "C" void vtkMatrix4x4_destructor (vtkMatrix4x4 * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_matrix_4_x_4_zero(vtkMatrix4x4* sself) { sself->Zero(); } +extern "C" void vtk_matrix_4_x_4_identity(vtkMatrix4x4* sself) { sself->Identity(); } +extern "C" bool vtk_matrix_4_x_4_is_identity(vtkMatrix4x4* sself) { return sself->IsIdentity(); } +extern "C" double vtk_matrix_4_x_4_determinant(vtkMatrix4x4* sself) { return sself->Determinant(); } +extern "C" void vtk_matrix_4_x_4_set_element(vtkMatrix4x4* sself, int i, int j, double value) { sself->SetElement(i, j, value); } +extern "C" double vtk_matrix_4_x_4_get_element(vtkMatrix4x4* sself, int i, int j) { return sself->GetElement(i, j); } +extern "C" vtkPolynomialSolversUnivariate * vtkPolynomialSolversUnivariate_new () {return vtkPolynomialSolversUnivariate :: New () ;} +extern "C" void vtkPolynomialSolversUnivariate_destructor (vtkPolynomialSolversUnivariate * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_polynomial_solvers_univariate_set_division_tolerance(vtkPolynomialSolversUnivariate* sself, double tol) { sself->SetDivisionTolerance(tol); } +extern "C" double vtk_polynomial_solvers_univariate_get_division_tolerance(vtkPolynomialSolversUnivariate* sself) { return sself->GetDivisionTolerance(); } +extern "C" vtkQuaternionInterpolator * vtkQuaternionInterpolator_new () {return vtkQuaternionInterpolator :: New () ;} +extern "C" void vtkQuaternionInterpolator_destructor (vtkQuaternionInterpolator * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_quaternion_interpolator_get_number_of_quaternions(vtkQuaternionInterpolator* sself) { return sself->GetNumberOfQuaternions(); } +extern "C" double vtk_quaternion_interpolator_get_minimum_t(vtkQuaternionInterpolator* sself) { return sself->GetMinimumT(); } +extern "C" double vtk_quaternion_interpolator_get_maximum_t(vtkQuaternionInterpolator* sself) { return sself->GetMaximumT(); } +extern "C" void vtk_quaternion_interpolator_initialize(vtkQuaternionInterpolator* sself) { sself->Initialize(); } +extern "C" void vtk_quaternion_interpolator_remove_quaternion(vtkQuaternionInterpolator* sself, double t) { sself->RemoveQuaternion(t); } +extern "C" int vtk_quaternion_interpolator_get_search_method(vtkQuaternionInterpolator* sself) { return sself->GetSearchMethod(); } +extern "C" void vtk_quaternion_interpolator_set_search_method(vtkQuaternionInterpolator* sself, int type) { sself->SetSearchMethod(type); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type(vtkQuaternionInterpolator* sself, int _arg) { sself->SetInterpolationType(_arg); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_min_value(vtkQuaternionInterpolator* sself) { return sself->GetInterpolationTypeMinValue(); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type_max_value(vtkQuaternionInterpolator* sself) { return sself->GetInterpolationTypeMaxValue(); } +extern "C" int vtk_quaternion_interpolator_get_interpolation_type(vtkQuaternionInterpolator* sself) { return sself->GetInterpolationType(); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_linear(vtkQuaternionInterpolator* sself) { sself->SetInterpolationTypeToLinear(); } +extern "C" void vtk_quaternion_interpolator_set_interpolation_type_to_spline(vtkQuaternionInterpolator* sself) { sself->SetInterpolationTypeToSpline(); } +extern "C" vtkRungeKutta2 * vtkRungeKutta2_new () {return vtkRungeKutta2 :: New () ;} +extern "C" void vtkRungeKutta2_destructor (vtkRungeKutta2 * sself) {sself -> Delete () ; return ;} +extern "C" vtkRungeKutta4 * vtkRungeKutta4_new () {return vtkRungeKutta4 :: New () ;} +extern "C" void vtkRungeKutta4_destructor (vtkRungeKutta4 * sself) {sself -> Delete () ; return ;} +extern "C" vtkRungeKutta45 * vtkRungeKutta45_new () {return vtkRungeKutta45 :: New () ;} +extern "C" void vtkRungeKutta45_destructor (vtkRungeKutta45 * sself) {sself -> Delete () ; return ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp index 09815bd..c73a162 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_misc.cpp @@ -15,18 +15,81 @@ #include // Implement declared functions -extern "C" vtkNew < vtkContourValues > vtkContourValues_new () {return vtkNew < vtkContourValues > () ;} -extern "C" void vtkContourValues_destructor (vtkNew < vtkContourValues > sself) {sself . Reset () ; return ;} -extern "C" void * vtkContourValues_get_ptr (vtkNew < vtkContourValues > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExprTkFunctionParser > vtkExprTkFunctionParser_new () {return vtkNew < vtkExprTkFunctionParser > () ;} -extern "C" void vtkExprTkFunctionParser_destructor (vtkNew < vtkExprTkFunctionParser > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExprTkFunctionParser_get_ptr (vtkNew < vtkExprTkFunctionParser > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkFunctionParser > vtkFunctionParser_new () {return vtkNew < vtkFunctionParser > () ;} -extern "C" void vtkFunctionParser_destructor (vtkNew < vtkFunctionParser > sself) {sself . Reset () ; return ;} -extern "C" void * vtkFunctionParser_get_ptr (vtkNew < vtkFunctionParser > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkHeap > vtkHeap_new () {return vtkNew < vtkHeap > () ;} -extern "C" void vtkHeap_destructor (vtkNew < vtkHeap > sself) {sself . Reset () ; return ;} -extern "C" void * vtkHeap_get_ptr (vtkNew < vtkHeap > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkResourceFileLocator > vtkResourceFileLocator_new () {return vtkNew < vtkResourceFileLocator > () ;} -extern "C" void vtkResourceFileLocator_destructor (vtkNew < vtkResourceFileLocator > sself) {sself . Reset () ; return ;} -extern "C" void * vtkResourceFileLocator_get_ptr (vtkNew < vtkResourceFileLocator > sself) {return sself . GetPointer () ;} +extern "C" vtkContourValues * vtkContourValues_new () {return vtkContourValues :: New () ;} +extern "C" void vtkContourValues_destructor (vtkContourValues * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_contour_values_set_value(vtkContourValues* sself, int i, double value) { sself->SetValue(i, value); } +extern "C" double vtk_contour_values_get_value(vtkContourValues* sself, int i) { return sself->GetValue(i); } +extern "C" void vtk_contour_values_set_number_of_contours(vtkContourValues* sself, const int number) { sself->SetNumberOfContours(number); } +extern "C" int vtk_contour_values_get_number_of_contours(vtkContourValues* sself) { return sself->GetNumberOfContours(); } +extern "C" void vtk_contour_values_generate_values(vtkContourValues* sself, int numContours, double rangeStart, double rangeEnd) { sself->GenerateValues(numContours, rangeStart, rangeEnd); } +extern "C" vtkExprTkFunctionParser * vtkExprTkFunctionParser_new () {return vtkExprTkFunctionParser :: New () ;} +extern "C" void vtkExprTkFunctionParser_destructor (vtkExprTkFunctionParser * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_expr_tk_function_parser_get_m_time(vtkExprTkFunctionParser* sself) { return sself->GetMTime(); } +extern "C" void vtk_expr_tk_function_parser_set_function(vtkExprTkFunctionParser* sself, const char* function) { sself->SetFunction(function); } +extern "C" const char* vtk_expr_tk_function_parser_get_function(vtkExprTkFunctionParser* sself) { return sself->GetFunction(); } +extern "C" int vtk_expr_tk_function_parser_is_scalar_result(vtkExprTkFunctionParser* sself) { return sself->IsScalarResult(); } +extern "C" int vtk_expr_tk_function_parser_is_vector_result(vtkExprTkFunctionParser* sself) { return sself->IsVectorResult(); } +extern "C" double vtk_expr_tk_function_parser_get_scalar_result(vtkExprTkFunctionParser* sself) { return sself->GetScalarResult(); } +extern "C" void vtk_expr_tk_function_parser_set_scalar_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName, double value) { sself->SetScalarVariableValue(variableName, value); } +extern "C" double vtk_expr_tk_function_parser_get_scalar_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName) { return sself->GetScalarVariableValue(variableName); } +extern "C" void vtk_expr_tk_function_parser_set_vector_variable_value(vtkExprTkFunctionParser* sself, const char*& variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } +extern "C" int vtk_expr_tk_function_parser_get_number_of_scalar_variables(vtkExprTkFunctionParser* sself) { return sself->GetNumberOfScalarVariables(); } +extern "C" int vtk_expr_tk_function_parser_get_scalar_variable_index(vtkExprTkFunctionParser* sself, const char*& name) { return sself->GetScalarVariableIndex(name); } +extern "C" int vtk_expr_tk_function_parser_get_number_of_vector_variables(vtkExprTkFunctionParser* sself) { return sself->GetNumberOfVectorVariables(); } +extern "C" int vtk_expr_tk_function_parser_get_vector_variable_index(vtkExprTkFunctionParser* sself, const char*& name) { return sself->GetVectorVariableIndex(name); } +extern "C" bool vtk_expr_tk_function_parser_get_scalar_variable_needed(vtkExprTkFunctionParser* sself, int i) { return sself->GetScalarVariableNeeded(i); } +extern "C" bool vtk_expr_tk_function_parser_get_vector_variable_needed(vtkExprTkFunctionParser* sself, int i) { return sself->GetVectorVariableNeeded(i); } +extern "C" void vtk_expr_tk_function_parser_remove_all_variables(vtkExprTkFunctionParser* sself) { sself->RemoveAllVariables(); } +extern "C" void vtk_expr_tk_function_parser_remove_scalar_variables(vtkExprTkFunctionParser* sself) { sself->RemoveScalarVariables(); } +extern "C" void vtk_expr_tk_function_parser_remove_vector_variables(vtkExprTkFunctionParser* sself) { sself->RemoveVectorVariables(); } +extern "C" void vtk_expr_tk_function_parser_set_replace_invalid_values(vtkExprTkFunctionParser* sself, int _arg) { sself->SetReplaceInvalidValues(_arg); } +extern "C" int vtk_expr_tk_function_parser_get_replace_invalid_values(vtkExprTkFunctionParser* sself) { return sself->GetReplaceInvalidValues(); } +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_on(vtkExprTkFunctionParser* sself) { sself->ReplaceInvalidValuesOn(); } +extern "C" void vtk_expr_tk_function_parser_replace_invalid_values_off(vtkExprTkFunctionParser* sself) { sself->ReplaceInvalidValuesOff(); } +extern "C" void vtk_expr_tk_function_parser_set_replacement_value(vtkExprTkFunctionParser* sself, double _arg) { sself->SetReplacementValue(_arg); } +extern "C" double vtk_expr_tk_function_parser_get_replacement_value(vtkExprTkFunctionParser* sself) { return sself->GetReplacementValue(); } +extern "C" void vtk_expr_tk_function_parser_invalidate_function(vtkExprTkFunctionParser* sself) { sself->InvalidateFunction(); } +extern "C" vtkFunctionParser * vtkFunctionParser_new () {return vtkFunctionParser :: New () ;} +extern "C" void vtkFunctionParser_destructor (vtkFunctionParser * sself) {sself -> Delete () ; return ;} +extern "C" unsigned long vtk_function_parser_get_m_time(vtkFunctionParser* sself) { return sself->GetMTime(); } +extern "C" void vtk_function_parser_set_function(vtkFunctionParser* sself, const char* function) { sself->SetFunction(function); } +extern "C" int vtk_function_parser_is_scalar_result(vtkFunctionParser* sself) { return sself->IsScalarResult(); } +extern "C" int vtk_function_parser_is_vector_result(vtkFunctionParser* sself) { return sself->IsVectorResult(); } +extern "C" double vtk_function_parser_get_scalar_result(vtkFunctionParser* sself) { return sself->GetScalarResult(); } +extern "C" void vtk_function_parser_set_scalar_variable_value(vtkFunctionParser* sself, const char* variableName, double value) { sself->SetScalarVariableValue(variableName, value); } +extern "C" double vtk_function_parser_get_scalar_variable_value(vtkFunctionParser* sself, const char* variableName) { return sself->GetScalarVariableValue(variableName); } +extern "C" void vtk_function_parser_set_vector_variable_value(vtkFunctionParser* sself, const char* variableName, double xValue, double yValue, double zValue) { sself->SetVectorVariableValue(variableName, xValue, yValue, zValue); } +extern "C" int vtk_function_parser_get_number_of_scalar_variables(vtkFunctionParser* sself) { return sself->GetNumberOfScalarVariables(); } +extern "C" int vtk_function_parser_get_scalar_variable_index(vtkFunctionParser* sself, const char* name) { return sself->GetScalarVariableIndex(name); } +extern "C" int vtk_function_parser_get_number_of_vector_variables(vtkFunctionParser* sself) { return sself->GetNumberOfVectorVariables(); } +extern "C" int vtk_function_parser_get_vector_variable_index(vtkFunctionParser* sself, const char* name) { return sself->GetVectorVariableIndex(name); } +extern "C" const char* vtk_function_parser_get_scalar_variable_name(vtkFunctionParser* sself, int i) { return sself->GetScalarVariableName(i); } +extern "C" const char* vtk_function_parser_get_vector_variable_name(vtkFunctionParser* sself, int i) { return sself->GetVectorVariableName(i); } +extern "C" bool vtk_function_parser_get_scalar_variable_needed(vtkFunctionParser* sself, int i) { return sself->GetScalarVariableNeeded(i); } +extern "C" bool vtk_function_parser_get_vector_variable_needed(vtkFunctionParser* sself, int i) { return sself->GetVectorVariableNeeded(i); } +extern "C" void vtk_function_parser_remove_all_variables(vtkFunctionParser* sself) { sself->RemoveAllVariables(); } +extern "C" void vtk_function_parser_remove_scalar_variables(vtkFunctionParser* sself) { sself->RemoveScalarVariables(); } +extern "C" void vtk_function_parser_remove_vector_variables(vtkFunctionParser* sself) { sself->RemoveVectorVariables(); } +extern "C" void vtk_function_parser_set_replace_invalid_values(vtkFunctionParser* sself, int _arg) { sself->SetReplaceInvalidValues(_arg); } +extern "C" int vtk_function_parser_get_replace_invalid_values(vtkFunctionParser* sself) { return sself->GetReplaceInvalidValues(); } +extern "C" void vtk_function_parser_replace_invalid_values_on(vtkFunctionParser* sself) { sself->ReplaceInvalidValuesOn(); } +extern "C" void vtk_function_parser_replace_invalid_values_off(vtkFunctionParser* sself) { sself->ReplaceInvalidValuesOff(); } +extern "C" void vtk_function_parser_set_replacement_value(vtkFunctionParser* sself, double _arg) { sself->SetReplacementValue(_arg); } +extern "C" double vtk_function_parser_get_replacement_value(vtkFunctionParser* sself) { return sself->GetReplacementValue(); } +extern "C" void vtk_function_parser_invalidate_function(vtkFunctionParser* sself) { sself->InvalidateFunction(); } +extern "C" vtkHeap * vtkHeap_new () {return vtkHeap :: New () ;} +extern "C" void vtkHeap_destructor (vtkHeap * sself) {sself -> Delete () ; return ;} +extern "C" void* vtk_heap_allocate_memory(vtkHeap* sself, size_t n) { return sself->AllocateMemory(n); } +extern "C" void vtk_heap_set_block_size(vtkHeap* sself, size_t p0) { sself->SetBlockSize(p0); } +extern "C" size_t vtk_heap_get_block_size(vtkHeap* sself) { return sself->GetBlockSize(); } +extern "C" int vtk_heap_get_number_of_blocks(vtkHeap* sself) { return sself->GetNumberOfBlocks(); } +extern "C" int vtk_heap_get_number_of_allocations(vtkHeap* sself) { return sself->GetNumberOfAllocations(); } +extern "C" void vtk_heap_reset(vtkHeap* sself) { sself->Reset(); } +extern "C" vtkResourceFileLocator * vtkResourceFileLocator_new () {return vtkResourceFileLocator :: New () ;} +extern "C" void vtkResourceFileLocator_destructor (vtkResourceFileLocator * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_resource_file_locator_set_print_debug_information(vtkResourceFileLocator* sself, bool p0) { sself->SetPrintDebugInformation(p0); } +extern "C" bool vtk_resource_file_locator_get_print_debug_information(vtkResourceFileLocator* sself) { return sself->GetPrintDebugInformation(); } +extern "C" void vtk_resource_file_locator_print_debug_information_on(vtkResourceFileLocator* sself) { sself->PrintDebugInformationOn(); } +extern "C" void vtk_resource_file_locator_print_debug_information_off(vtkResourceFileLocator* sself) { sself->PrintDebugInformationOff(); } +extern "C" void vtk_resource_file_locator_set_log_verbosity(vtkResourceFileLocator* sself, int _arg) { sself->SetLogVerbosity(_arg); } +extern "C" int vtk_resource_file_locator_get_log_verbosity(vtkResourceFileLocator* sself) { return sself->GetLogVerbosity(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp index ad66e6f..1419b6e 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_system.cpp @@ -18,24 +18,68 @@ #include // Implement declared functions -extern "C" vtkNew < vtkClientSocket > vtkClientSocket_new () {return vtkNew < vtkClientSocket > () ;} -extern "C" void vtkClientSocket_destructor (vtkNew < vtkClientSocket > sself) {sself . Reset () ; return ;} -extern "C" void * vtkClientSocket_get_ptr (vtkNew < vtkClientSocket > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkDirectory > vtkDirectory_new () {return vtkNew < vtkDirectory > () ;} -extern "C" void vtkDirectory_destructor (vtkNew < vtkDirectory > sself) {sself . Reset () ; return ;} -extern "C" void * vtkDirectory_get_ptr (vtkNew < vtkDirectory > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkExecutableRunner > vtkExecutableRunner_new () {return vtkNew < vtkExecutableRunner > () ;} -extern "C" void vtkExecutableRunner_destructor (vtkNew < vtkExecutableRunner > sself) {sself . Reset () ; return ;} -extern "C" void * vtkExecutableRunner_get_ptr (vtkNew < vtkExecutableRunner > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkServerSocket > vtkServerSocket_new () {return vtkNew < vtkServerSocket > () ;} -extern "C" void vtkServerSocket_destructor (vtkNew < vtkServerSocket > sself) {sself . Reset () ; return ;} -extern "C" void * vtkServerSocket_get_ptr (vtkNew < vtkServerSocket > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSocketCollection > vtkSocketCollection_new () {return vtkNew < vtkSocketCollection > () ;} -extern "C" void vtkSocketCollection_destructor (vtkNew < vtkSocketCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSocketCollection_get_ptr (vtkNew < vtkSocketCollection > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkThreadMessager > vtkThreadMessager_new () {return vtkNew < vtkThreadMessager > () ;} -extern "C" void vtkThreadMessager_destructor (vtkNew < vtkThreadMessager > sself) {sself . Reset () ; return ;} -extern "C" void * vtkThreadMessager_get_ptr (vtkNew < vtkThreadMessager > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTimerLog > vtkTimerLog_new () {return vtkNew < vtkTimerLog > () ;} -extern "C" void vtkTimerLog_destructor (vtkNew < vtkTimerLog > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTimerLog_get_ptr (vtkNew < vtkTimerLog > sself) {return sself . GetPointer () ;} +extern "C" vtkClientSocket * vtkClientSocket_new () {return vtkClientSocket :: New () ;} +extern "C" void vtkClientSocket_destructor (vtkClientSocket * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_client_socket_connect_to_server(vtkClientSocket* sself, const char* hostname, int port) { return sself->ConnectToServer(hostname, port); } +extern "C" bool vtk_client_socket_get_connecting_side(vtkClientSocket* sself) { return sself->GetConnectingSide(); } +extern "C" vtkDirectory * vtkDirectory_new () {return vtkDirectory :: New () ;} +extern "C" void vtkDirectory_destructor (vtkDirectory * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_directory_open(vtkDirectory* sself, const char* dir) { return sself->Open(dir); } +extern "C" long long vtk_directory_get_number_of_files(vtkDirectory* sself) { return sself->GetNumberOfFiles(); } +extern "C" const char* vtk_directory_get_file(vtkDirectory* sself, long long index) { return sself->GetFile(index); } +extern "C" int vtk_directory_file_is_directory(vtkDirectory* sself, const char* name) { return sself->FileIsDirectory(name); } +extern "C" int vtk_directory_make_directory(vtkDirectory* sself, const char* dir) { return sself->MakeDirectory(dir); } +extern "C" int vtk_directory_delete_directory(vtkDirectory* sself, const char* dir) { return sself->DeleteDirectory(dir); } +extern "C" int vtk_directory_rename(vtkDirectory* sself, const char* oldname, const char* newname) { return sself->Rename(oldname, newname); } +extern "C" vtkExecutableRunner * vtkExecutableRunner_new () {return vtkExecutableRunner :: New () ;} +extern "C" void vtkExecutableRunner_destructor (vtkExecutableRunner * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_executable_runner_execute(vtkExecutableRunner* sself) { sself->Execute(); } +extern "C" void vtk_executable_runner_set_timeout(vtkExecutableRunner* sself, double _arg) { sself->SetTimeout(_arg); } +extern "C" double vtk_executable_runner_get_timeout(vtkExecutableRunner* sself) { return sself->GetTimeout(); } +extern "C" void vtk_executable_runner_set_right_trim_result(vtkExecutableRunner* sself, bool _arg) { sself->SetRightTrimResult(_arg); } +extern "C" bool vtk_executable_runner_get_right_trim_result(vtkExecutableRunner* sself) { return sself->GetRightTrimResult(); } +extern "C" void vtk_executable_runner_right_trim_result_on(vtkExecutableRunner* sself) { sself->RightTrimResultOn(); } +extern "C" void vtk_executable_runner_right_trim_result_off(vtkExecutableRunner* sself) { sself->RightTrimResultOff(); } +extern "C" const char* vtk_executable_runner_get_command(vtkExecutableRunner* sself) { return sself->GetCommand(); } +extern "C" void vtk_executable_runner_set_command(vtkExecutableRunner* sself, const char* arg) { sself->SetCommand(arg); } +extern "C" const char* vtk_executable_runner_get_std_out(vtkExecutableRunner* sself) { return sself->GetStdOut(); } +extern "C" const char* vtk_executable_runner_get_std_err(vtkExecutableRunner* sself) { return sself->GetStdErr(); } +extern "C" int vtk_executable_runner_get_return_value(vtkExecutableRunner* sself) { return sself->GetReturnValue(); } +extern "C" vtkServerSocket * vtkServerSocket_new () {return vtkServerSocket :: New () ;} +extern "C" void vtkServerSocket_destructor (vtkServerSocket * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_server_socket_create_server(vtkServerSocket* sself, int port) { return sself->CreateServer(port); } +extern "C" int vtk_server_socket_get_server_port(vtkServerSocket* sself) { return sself->GetServerPort(); } +extern "C" vtkSocketCollection * vtkSocketCollection_new () {return vtkSocketCollection :: New () ;} +extern "C" void vtkSocketCollection_destructor (vtkSocketCollection * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_socket_collection_select_sockets(vtkSocketCollection* sself, unsigned long msec) { return sself->SelectSockets(msec); } +extern "C" vtkThreadMessager * vtkThreadMessager_new () {return vtkThreadMessager :: New () ;} +extern "C" void vtkThreadMessager_destructor (vtkThreadMessager * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_thread_messager_wait_for_message(vtkThreadMessager* sself) { sself->WaitForMessage(); } +extern "C" void vtk_thread_messager_send_wake_message(vtkThreadMessager* sself) { sself->SendWakeMessage(); } +extern "C" void vtk_thread_messager_enable_wait_for_receiver(vtkThreadMessager* sself) { sself->EnableWaitForReceiver(); } +extern "C" void vtk_thread_messager_disable_wait_for_receiver(vtkThreadMessager* sself) { sself->DisableWaitForReceiver(); } +extern "C" void vtk_thread_messager_wait_for_receiver(vtkThreadMessager* sself) { sself->WaitForReceiver(); } +extern "C" vtkTimerLog * vtkTimerLog_new () {return vtkTimerLog :: New () ;} +extern "C" void vtkTimerLog_destructor (vtkTimerLog * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_timer_log_set_logging(vtkTimerLog* sself, int v) { sself->SetLogging(v); } +extern "C" int vtk_timer_log_get_logging(vtkTimerLog* sself) { return sself->GetLogging(); } +extern "C" void vtk_timer_log_logging_on(vtkTimerLog* sself) { sself->LoggingOn(); } +extern "C" void vtk_timer_log_logging_off(vtkTimerLog* sself) { sself->LoggingOff(); } +extern "C" void vtk_timer_log_set_max_entries(vtkTimerLog* sself, int a) { sself->SetMaxEntries(a); } +extern "C" int vtk_timer_log_get_max_entries(vtkTimerLog* sself) { return sself->GetMaxEntries(); } +extern "C" void vtk_timer_log_dump_log(vtkTimerLog* sself, const char* filename) { sself->DumpLog(filename); } +extern "C" void vtk_timer_log_mark_start_event(vtkTimerLog* sself, const char* EventString) { sself->MarkStartEvent(EventString); } +extern "C" void vtk_timer_log_mark_end_event(vtkTimerLog* sself, const char* EventString) { sself->MarkEndEvent(EventString); } +extern "C" void vtk_timer_log_insert_timed_event(vtkTimerLog* sself, const char* EventString, double time, int cpuTicks) { sself->InsertTimedEvent(EventString, time, cpuTicks); } +extern "C" int vtk_timer_log_get_number_of_events(vtkTimerLog* sself) { return sself->GetNumberOfEvents(); } +extern "C" int vtk_timer_log_get_event_indent(vtkTimerLog* sself, int i) { return sself->GetEventIndent(i); } +extern "C" double vtk_timer_log_get_event_wall_time(vtkTimerLog* sself, int i) { return sself->GetEventWallTime(i); } +extern "C" const char* vtk_timer_log_get_event_string(vtkTimerLog* sself, int i) { return sself->GetEventString(i); } +extern "C" void vtk_timer_log_mark_event(vtkTimerLog* sself, const char* EventString) { sself->MarkEvent(EventString); } +extern "C" void vtk_timer_log_reset_log(vtkTimerLog* sself) { sself->ResetLog(); } +extern "C" void vtk_timer_log_cleanup_log(vtkTimerLog* sself) { sself->CleanupLog(); } +extern "C" double vtk_timer_log_get_universal_time(vtkTimerLog* sself) { return sself->GetUniversalTime(); } +extern "C" double vtk_timer_log_get_cpu_time(vtkTimerLog* sself) { return sself->GetCPUTime(); } +extern "C" void vtk_timer_log_start_timer(vtkTimerLog* sself) { sself->StartTimer(); } +extern "C" void vtk_timer_log_stop_timer(vtkTimerLog* sself) { sself->StopTimer(); } +extern "C" double vtk_timer_log_get_elapsed_time(vtkTimerLog* sself) { return sself->GetElapsedTime(); } diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp index 8fc78c2..8073c30 100644 --- a/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp +++ b/vtk-rs-9.1/libvtkrs/src/vtk_common_transforms.cpp @@ -27,39 +27,111 @@ #include // Implement declared functions -extern "C" vtkNew < vtkCylindricalTransform > vtkCylindricalTransform_new () {return vtkNew < vtkCylindricalTransform > () ;} -extern "C" void vtkCylindricalTransform_destructor (vtkNew < vtkCylindricalTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkCylindricalTransform_get_ptr (vtkNew < vtkCylindricalTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkGeneralTransform > vtkGeneralTransform_new () {return vtkNew < vtkGeneralTransform > () ;} -extern "C" void vtkGeneralTransform_destructor (vtkNew < vtkGeneralTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkGeneralTransform_get_ptr (vtkNew < vtkGeneralTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkIdentityTransform > vtkIdentityTransform_new () {return vtkNew < vtkIdentityTransform > () ;} -extern "C" void vtkIdentityTransform_destructor (vtkNew < vtkIdentityTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkIdentityTransform_get_ptr (vtkNew < vtkIdentityTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkLandmarkTransform > vtkLandmarkTransform_new () {return vtkNew < vtkLandmarkTransform > () ;} -extern "C" void vtkLandmarkTransform_destructor (vtkNew < vtkLandmarkTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkLandmarkTransform_get_ptr (vtkNew < vtkLandmarkTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMatrixToHomogeneousTransform > vtkMatrixToHomogeneousTransform_new () {return vtkNew < vtkMatrixToHomogeneousTransform > () ;} -extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkNew < vtkMatrixToHomogeneousTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMatrixToHomogeneousTransform_get_ptr (vtkNew < vtkMatrixToHomogeneousTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkMatrixToLinearTransform > vtkMatrixToLinearTransform_new () {return vtkNew < vtkMatrixToLinearTransform > () ;} -extern "C" void vtkMatrixToLinearTransform_destructor (vtkNew < vtkMatrixToLinearTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkMatrixToLinearTransform_get_ptr (vtkNew < vtkMatrixToLinearTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkPerspectiveTransform > vtkPerspectiveTransform_new () {return vtkNew < vtkPerspectiveTransform > () ;} -extern "C" void vtkPerspectiveTransform_destructor (vtkNew < vtkPerspectiveTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkPerspectiveTransform_get_ptr (vtkNew < vtkPerspectiveTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkSphericalTransform > vtkSphericalTransform_new () {return vtkNew < vtkSphericalTransform > () ;} -extern "C" void vtkSphericalTransform_destructor (vtkNew < vtkSphericalTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkSphericalTransform_get_ptr (vtkNew < vtkSphericalTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkThinPlateSplineTransform > vtkThinPlateSplineTransform_new () {return vtkNew < vtkThinPlateSplineTransform > () ;} -extern "C" void vtkThinPlateSplineTransform_destructor (vtkNew < vtkThinPlateSplineTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkThinPlateSplineTransform_get_ptr (vtkNew < vtkThinPlateSplineTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTransform > vtkTransform_new () {return vtkNew < vtkTransform > () ;} -extern "C" void vtkTransform_destructor (vtkNew < vtkTransform > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTransform_get_ptr (vtkNew < vtkTransform > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTransform2D > vtkTransform2D_new () {return vtkNew < vtkTransform2D > () ;} -extern "C" void vtkTransform2D_destructor (vtkNew < vtkTransform2D > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTransform2D_get_ptr (vtkNew < vtkTransform2D > sself) {return sself . GetPointer () ;} -extern "C" vtkNew < vtkTransformCollection > vtkTransformCollection_new () {return vtkNew < vtkTransformCollection > () ;} -extern "C" void vtkTransformCollection_destructor (vtkNew < vtkTransformCollection > sself) {sself . Reset () ; return ;} -extern "C" void * vtkTransformCollection_get_ptr (vtkNew < vtkTransformCollection > sself) {return sself . GetPointer () ;} +extern "C" vtkCylindricalTransform * vtkCylindricalTransform_new () {return vtkCylindricalTransform :: New () ;} +extern "C" void vtkCylindricalTransform_destructor (vtkCylindricalTransform * sself) {sself -> Delete () ; return ;} +extern "C" vtkGeneralTransform * vtkGeneralTransform_new () {return vtkGeneralTransform :: New () ;} +extern "C" void vtkGeneralTransform_destructor (vtkGeneralTransform * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_general_transform_identity(vtkGeneralTransform* sself) { sself->Identity(); } +extern "C" void vtk_general_transform_inverse(vtkGeneralTransform* sself) { sself->Inverse(); } +extern "C" void vtk_general_transform_translate(vtkGeneralTransform* sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_general_transform_rotate_wxyz(vtkGeneralTransform* sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_general_transform_rotate_x(vtkGeneralTransform* sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_general_transform_rotate_y(vtkGeneralTransform* sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_general_transform_rotate_z(vtkGeneralTransform* sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_general_transform_scale(vtkGeneralTransform* sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_general_transform_pre_multiply(vtkGeneralTransform* sself) { sself->PreMultiply(); } +extern "C" void vtk_general_transform_post_multiply(vtkGeneralTransform* sself) { sself->PostMultiply(); } +extern "C" int vtk_general_transform_get_number_of_concatenated_transforms(vtkGeneralTransform* sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" int vtk_general_transform_get_inverse_flag(vtkGeneralTransform* sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_general_transform_push(vtkGeneralTransform* sself) { sself->Push(); } +extern "C" void vtk_general_transform_pop(vtkGeneralTransform* sself) { sself->Pop(); } +extern "C" unsigned long vtk_general_transform_get_m_time(vtkGeneralTransform* sself) { return sself->GetMTime(); } +extern "C" vtkIdentityTransform * vtkIdentityTransform_new () {return vtkIdentityTransform :: New () ;} +extern "C" void vtkIdentityTransform_destructor (vtkIdentityTransform * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_identity_transform_inverse(vtkIdentityTransform* sself) { sself->Inverse(); } +extern "C" vtkLandmarkTransform * vtkLandmarkTransform_new () {return vtkLandmarkTransform :: New () ;} +extern "C" void vtkLandmarkTransform_destructor (vtkLandmarkTransform * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_landmark_transform_set_mode(vtkLandmarkTransform* sself, int _arg) { sself->SetMode(_arg); } +extern "C" void vtk_landmark_transform_set_mode_to_rigid_body(vtkLandmarkTransform* sself) { sself->SetModeToRigidBody(); } +extern "C" void vtk_landmark_transform_set_mode_to_similarity(vtkLandmarkTransform* sself) { sself->SetModeToSimilarity(); } +extern "C" void vtk_landmark_transform_set_mode_to_affine(vtkLandmarkTransform* sself) { sself->SetModeToAffine(); } +extern "C" int vtk_landmark_transform_get_mode(vtkLandmarkTransform* sself) { return sself->GetMode(); } +extern "C" const char* vtk_landmark_transform_get_mode_as_string(vtkLandmarkTransform* sself) { return sself->GetModeAsString(); } +extern "C" void vtk_landmark_transform_inverse(vtkLandmarkTransform* sself) { sself->Inverse(); } +extern "C" unsigned long vtk_landmark_transform_get_m_time(vtkLandmarkTransform* sself) { return sself->GetMTime(); } +extern "C" vtkMatrixToHomogeneousTransform * vtkMatrixToHomogeneousTransform_new () {return vtkMatrixToHomogeneousTransform :: New () ;} +extern "C" void vtkMatrixToHomogeneousTransform_destructor (vtkMatrixToHomogeneousTransform * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_matrix_to_homogeneous_transform_inverse(vtkMatrixToHomogeneousTransform* sself) { sself->Inverse(); } +extern "C" unsigned long vtk_matrix_to_homogeneous_transform_get_m_time(vtkMatrixToHomogeneousTransform* sself) { return sself->GetMTime(); } +extern "C" vtkMatrixToLinearTransform * vtkMatrixToLinearTransform_new () {return vtkMatrixToLinearTransform :: New () ;} +extern "C" void vtkMatrixToLinearTransform_destructor (vtkMatrixToLinearTransform * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_matrix_to_linear_transform_inverse(vtkMatrixToLinearTransform* sself) { sself->Inverse(); } +extern "C" unsigned long vtk_matrix_to_linear_transform_get_m_time(vtkMatrixToLinearTransform* sself) { return sself->GetMTime(); } +extern "C" vtkPerspectiveTransform * vtkPerspectiveTransform_new () {return vtkPerspectiveTransform :: New () ;} +extern "C" void vtkPerspectiveTransform_destructor (vtkPerspectiveTransform * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_perspective_transform_identity(vtkPerspectiveTransform* sself) { sself->Identity(); } +extern "C" void vtk_perspective_transform_inverse(vtkPerspectiveTransform* sself) { sself->Inverse(); } +extern "C" void vtk_perspective_transform_adjust_viewport(vtkPerspectiveTransform* sself, double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax) { sself->AdjustViewport(oldXMin, oldXMax, oldYMin, oldYMax, newXMin, newXMax, newYMin, newYMax); } +extern "C" void vtk_perspective_transform_adjust_z_buffer(vtkPerspectiveTransform* sself, double oldNearZ, double oldFarZ, double newNearZ, double newFarZ) { sself->AdjustZBuffer(oldNearZ, oldFarZ, newNearZ, newFarZ); } +extern "C" void vtk_perspective_transform_ortho(vtkPerspectiveTransform* sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar) { sself->Ortho(xmin, xmax, ymin, ymax, znear, zfar); } +extern "C" void vtk_perspective_transform_frustum(vtkPerspectiveTransform* sself, double xmin, double xmax, double ymin, double ymax, double znear, double zfar) { sself->Frustum(xmin, xmax, ymin, ymax, znear, zfar); } +extern "C" void vtk_perspective_transform_perspective(vtkPerspectiveTransform* sself, double angle, double aspect, double znear, double zfar) { sself->Perspective(angle, aspect, znear, zfar); } +extern "C" void vtk_perspective_transform_shear(vtkPerspectiveTransform* sself, double dxdz, double dydz, double zplane) { sself->Shear(dxdz, dydz, zplane); } +extern "C" void vtk_perspective_transform_stereo(vtkPerspectiveTransform* sself, double angle, double focaldistance) { sself->Stereo(angle, focaldistance); } +extern "C" void vtk_perspective_transform_setup_camera(vtkPerspectiveTransform* sself, double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2) { sself->SetupCamera(p0, p1, p2, fp0, fp1, fp2, vup0, vup1, vup2); } +extern "C" void vtk_perspective_transform_translate(vtkPerspectiveTransform* sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_perspective_transform_rotate_wxyz(vtkPerspectiveTransform* sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_perspective_transform_rotate_x(vtkPerspectiveTransform* sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_perspective_transform_rotate_y(vtkPerspectiveTransform* sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_perspective_transform_rotate_z(vtkPerspectiveTransform* sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_perspective_transform_scale(vtkPerspectiveTransform* sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_perspective_transform_pre_multiply(vtkPerspectiveTransform* sself) { sself->PreMultiply(); } +extern "C" void vtk_perspective_transform_post_multiply(vtkPerspectiveTransform* sself) { sself->PostMultiply(); } +extern "C" int vtk_perspective_transform_get_number_of_concatenated_transforms(vtkPerspectiveTransform* sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" int vtk_perspective_transform_get_inverse_flag(vtkPerspectiveTransform* sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_perspective_transform_push(vtkPerspectiveTransform* sself) { sself->Push(); } +extern "C" void vtk_perspective_transform_pop(vtkPerspectiveTransform* sself) { sself->Pop(); } +extern "C" unsigned long vtk_perspective_transform_get_m_time(vtkPerspectiveTransform* sself) { return sself->GetMTime(); } +extern "C" vtkSphericalTransform * vtkSphericalTransform_new () {return vtkSphericalTransform :: New () ;} +extern "C" void vtkSphericalTransform_destructor (vtkSphericalTransform * sself) {sself -> Delete () ; return ;} +extern "C" vtkThinPlateSplineTransform * vtkThinPlateSplineTransform_new () {return vtkThinPlateSplineTransform :: New () ;} +extern "C" void vtkThinPlateSplineTransform_destructor (vtkThinPlateSplineTransform * sself) {sself -> Delete () ; return ;} +extern "C" double vtk_thin_plate_spline_transform_get_sigma(vtkThinPlateSplineTransform* sself) { return sself->GetSigma(); } +extern "C" void vtk_thin_plate_spline_transform_set_sigma(vtkThinPlateSplineTransform* sself, double _arg) { sself->SetSigma(_arg); } +extern "C" void vtk_thin_plate_spline_transform_set_basis(vtkThinPlateSplineTransform* sself, int basis) { sself->SetBasis(basis); } +extern "C" int vtk_thin_plate_spline_transform_get_basis(vtkThinPlateSplineTransform* sself) { return sself->GetBasis(); } +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r(vtkThinPlateSplineTransform* sself) { sself->SetBasisToR(); } +extern "C" void vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(vtkThinPlateSplineTransform* sself) { sself->SetBasisToR2LogR(); } +extern "C" const char* vtk_thin_plate_spline_transform_get_basis_as_string(vtkThinPlateSplineTransform* sself) { return sself->GetBasisAsString(); } +extern "C" unsigned long vtk_thin_plate_spline_transform_get_m_time(vtkThinPlateSplineTransform* sself) { return sself->GetMTime(); } +extern "C" bool vtk_thin_plate_spline_transform_get_regularize_bulk_transform(vtkThinPlateSplineTransform* sself) { return sself->GetRegularizeBulkTransform(); } +extern "C" void vtk_thin_plate_spline_transform_set_regularize_bulk_transform(vtkThinPlateSplineTransform* sself, bool _arg) { sself->SetRegularizeBulkTransform(_arg); } +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_on(vtkThinPlateSplineTransform* sself) { sself->RegularizeBulkTransformOn(); } +extern "C" void vtk_thin_plate_spline_transform_regularize_bulk_transform_off(vtkThinPlateSplineTransform* sself) { sself->RegularizeBulkTransformOff(); } +extern "C" vtkTransform * vtkTransform_new () {return vtkTransform :: New () ;} +extern "C" void vtkTransform_destructor (vtkTransform * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_transform_identity(vtkTransform* sself) { sself->Identity(); } +extern "C" void vtk_transform_inverse(vtkTransform* sself) { sself->Inverse(); } +extern "C" void vtk_transform_translate(vtkTransform* sself, double x, double y, double z) { sself->Translate(x, y, z); } +extern "C" void vtk_transform_rotate_wxyz(vtkTransform* sself, double angle, double x, double y, double z) { sself->RotateWXYZ(angle, x, y, z); } +extern "C" void vtk_transform_rotate_x(vtkTransform* sself, double angle) { sself->RotateX(angle); } +extern "C" void vtk_transform_rotate_y(vtkTransform* sself, double angle) { sself->RotateY(angle); } +extern "C" void vtk_transform_rotate_z(vtkTransform* sself, double angle) { sself->RotateZ(angle); } +extern "C" void vtk_transform_scale(vtkTransform* sself, double x, double y, double z) { sself->Scale(x, y, z); } +extern "C" void vtk_transform_pre_multiply(vtkTransform* sself) { sself->PreMultiply(); } +extern "C" void vtk_transform_post_multiply(vtkTransform* sself) { sself->PostMultiply(); } +extern "C" int vtk_transform_get_number_of_concatenated_transforms(vtkTransform* sself) { return sself->GetNumberOfConcatenatedTransforms(); } +extern "C" int vtk_transform_get_inverse_flag(vtkTransform* sself) { return sself->GetInverseFlag(); } +extern "C" void vtk_transform_push(vtkTransform* sself) { sself->Push(); } +extern "C" void vtk_transform_pop(vtkTransform* sself) { sself->Pop(); } +extern "C" unsigned long vtk_transform_get_m_time(vtkTransform* sself) { return sself->GetMTime(); } +extern "C" vtkTransform2D * vtkTransform2D_new () {return vtkTransform2D :: New () ;} +extern "C" void vtkTransform2D_destructor (vtkTransform2D * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_transform_2_d_identity(vtkTransform2D* sself) { sself->Identity(); } +extern "C" void vtk_transform_2_d_inverse(vtkTransform2D* sself) { sself->Inverse(); } +extern "C" void vtk_transform_2_d_translate(vtkTransform2D* sself, double x, double y) { sself->Translate(x, y); } +extern "C" void vtk_transform_2_d_rotate(vtkTransform2D* sself, double angle) { sself->Rotate(angle); } +extern "C" void vtk_transform_2_d_scale(vtkTransform2D* sself, double x, double y) { sself->Scale(x, y); } +extern "C" unsigned long vtk_transform_2_d_get_m_time(vtkTransform2D* sself) { return sself->GetMTime(); } +extern "C" vtkTransformCollection * vtkTransformCollection_new () {return vtkTransformCollection :: New () ;} +extern "C" void vtkTransformCollection_destructor (vtkTransformCollection * sself) {sself -> Delete () ; return ;} diff --git a/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp b/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp new file mode 100644 index 0000000..f2226a4 --- /dev/null +++ b/vtk-rs-9.1/libvtkrs/src/vtk_filters_sources.cpp @@ -0,0 +1,802 @@ +// Include header file +#include + +// Default include in all modules +#include +#include + +// Include objects of this module +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Implement declared functions +extern "C" vtkArcSource * vtkArcSource_new () {return vtkArcSource :: New () ;} +extern "C" void vtkArcSource_destructor (vtkArcSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_arc_source_set_point_1(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint1(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_point_2(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint2(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_center(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_normal(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_polar_vector(vtkArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPolarVector(_arg1, _arg2, _arg3); } +extern "C" void vtk_arc_source_set_angle(vtkArcSource* sself, double _arg) { sself->SetAngle(_arg); } +extern "C" double vtk_arc_source_get_angle_min_value(vtkArcSource* sself) { return sself->GetAngleMinValue(); } +extern "C" double vtk_arc_source_get_angle_max_value(vtkArcSource* sself) { return sself->GetAngleMaxValue(); } +extern "C" double vtk_arc_source_get_angle(vtkArcSource* sself) { return sself->GetAngle(); } +extern "C" void vtk_arc_source_set_resolution(vtkArcSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_arc_source_get_resolution_min_value(vtkArcSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_arc_source_get_resolution_max_value(vtkArcSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_arc_source_get_resolution(vtkArcSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_arc_source_set_negative(vtkArcSource* sself, bool _arg) { sself->SetNegative(_arg); } +extern "C" bool vtk_arc_source_get_negative(vtkArcSource* sself) { return sself->GetNegative(); } +extern "C" void vtk_arc_source_negative_on(vtkArcSource* sself) { sself->NegativeOn(); } +extern "C" void vtk_arc_source_negative_off(vtkArcSource* sself) { sself->NegativeOff(); } +extern "C" void vtk_arc_source_set_use_normal_and_angle(vtkArcSource* sself, bool _arg) { sself->SetUseNormalAndAngle(_arg); } +extern "C" bool vtk_arc_source_get_use_normal_and_angle(vtkArcSource* sself) { return sself->GetUseNormalAndAngle(); } +extern "C" void vtk_arc_source_use_normal_and_angle_on(vtkArcSource* sself) { sself->UseNormalAndAngleOn(); } +extern "C" void vtk_arc_source_use_normal_and_angle_off(vtkArcSource* sself) { sself->UseNormalAndAngleOff(); } +extern "C" void vtk_arc_source_set_output_points_precision(vtkArcSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_arc_source_get_output_points_precision(vtkArcSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkArrowSource * vtkArrowSource_new () {return vtkArrowSource :: New () ;} +extern "C" void vtkArrowSource_destructor (vtkArrowSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_arrow_source_set_tip_length(vtkArrowSource* sself, double _arg) { sself->SetTipLength(_arg); } +extern "C" double vtk_arrow_source_get_tip_length_min_value(vtkArrowSource* sself) { return sself->GetTipLengthMinValue(); } +extern "C" double vtk_arrow_source_get_tip_length_max_value(vtkArrowSource* sself) { return sself->GetTipLengthMaxValue(); } +extern "C" double vtk_arrow_source_get_tip_length(vtkArrowSource* sself) { return sself->GetTipLength(); } +extern "C" void vtk_arrow_source_set_tip_radius(vtkArrowSource* sself, double _arg) { sself->SetTipRadius(_arg); } +extern "C" double vtk_arrow_source_get_tip_radius_min_value(vtkArrowSource* sself) { return sself->GetTipRadiusMinValue(); } +extern "C" double vtk_arrow_source_get_tip_radius_max_value(vtkArrowSource* sself) { return sself->GetTipRadiusMaxValue(); } +extern "C" double vtk_arrow_source_get_tip_radius(vtkArrowSource* sself) { return sself->GetTipRadius(); } +extern "C" void vtk_arrow_source_set_tip_resolution(vtkArrowSource* sself, int _arg) { sself->SetTipResolution(_arg); } +extern "C" int vtk_arrow_source_get_tip_resolution_min_value(vtkArrowSource* sself) { return sself->GetTipResolutionMinValue(); } +extern "C" int vtk_arrow_source_get_tip_resolution_max_value(vtkArrowSource* sself) { return sself->GetTipResolutionMaxValue(); } +extern "C" int vtk_arrow_source_get_tip_resolution(vtkArrowSource* sself) { return sself->GetTipResolution(); } +extern "C" void vtk_arrow_source_set_shaft_radius(vtkArrowSource* sself, double _arg) { sself->SetShaftRadius(_arg); } +extern "C" double vtk_arrow_source_get_shaft_radius_min_value(vtkArrowSource* sself) { return sself->GetShaftRadiusMinValue(); } +extern "C" double vtk_arrow_source_get_shaft_radius_max_value(vtkArrowSource* sself) { return sself->GetShaftRadiusMaxValue(); } +extern "C" double vtk_arrow_source_get_shaft_radius(vtkArrowSource* sself) { return sself->GetShaftRadius(); } +extern "C" void vtk_arrow_source_set_shaft_resolution(vtkArrowSource* sself, int _arg) { sself->SetShaftResolution(_arg); } +extern "C" int vtk_arrow_source_get_shaft_resolution_min_value(vtkArrowSource* sself) { return sself->GetShaftResolutionMinValue(); } +extern "C" int vtk_arrow_source_get_shaft_resolution_max_value(vtkArrowSource* sself) { return sself->GetShaftResolutionMaxValue(); } +extern "C" int vtk_arrow_source_get_shaft_resolution(vtkArrowSource* sself) { return sself->GetShaftResolution(); } +extern "C" void vtk_arrow_source_invert_on(vtkArrowSource* sself) { sself->InvertOn(); } +extern "C" void vtk_arrow_source_invert_off(vtkArrowSource* sself) { sself->InvertOff(); } +extern "C" void vtk_arrow_source_set_invert(vtkArrowSource* sself, bool _arg) { sself->SetInvert(_arg); } +extern "C" bool vtk_arrow_source_get_invert(vtkArrowSource* sself) { return sself->GetInvert(); } +extern "C" void vtk_arrow_source_set_arrow_origin_to_default(vtkArrowSource* sself) { sself->SetArrowOriginToDefault(); } +extern "C" void vtk_arrow_source_set_arrow_origin_to_center(vtkArrowSource* sself) { sself->SetArrowOriginToCenter(); } +extern "C" vtkCapsuleSource * vtkCapsuleSource_new () {return vtkCapsuleSource :: New () ;} +extern "C" void vtkCapsuleSource_destructor (vtkCapsuleSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_capsule_source_set_radius(vtkCapsuleSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_capsule_source_get_radius_min_value(vtkCapsuleSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_capsule_source_get_radius_max_value(vtkCapsuleSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_capsule_source_get_radius(vtkCapsuleSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_capsule_source_set_center(vtkCapsuleSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_capsule_source_set_cylinder_length(vtkCapsuleSource* sself, double _arg) { sself->SetCylinderLength(_arg); } +extern "C" double vtk_capsule_source_get_cylinder_length_min_value(vtkCapsuleSource* sself) { return sself->GetCylinderLengthMinValue(); } +extern "C" double vtk_capsule_source_get_cylinder_length_max_value(vtkCapsuleSource* sself) { return sself->GetCylinderLengthMaxValue(); } +extern "C" double vtk_capsule_source_get_cylinder_length(vtkCapsuleSource* sself) { return sself->GetCylinderLength(); } +extern "C" void vtk_capsule_source_set_theta_resolution(vtkCapsuleSource* sself, int _arg) { sself->SetThetaResolution(_arg); } +extern "C" int vtk_capsule_source_get_theta_resolution_min_value(vtkCapsuleSource* sself) { return sself->GetThetaResolutionMinValue(); } +extern "C" int vtk_capsule_source_get_theta_resolution_max_value(vtkCapsuleSource* sself) { return sself->GetThetaResolutionMaxValue(); } +extern "C" int vtk_capsule_source_get_theta_resolution(vtkCapsuleSource* sself) { return sself->GetThetaResolution(); } +extern "C" void vtk_capsule_source_set_phi_resolution(vtkCapsuleSource* sself, int _arg) { sself->SetPhiResolution(_arg); } +extern "C" int vtk_capsule_source_get_phi_resolution_min_value(vtkCapsuleSource* sself) { return sself->GetPhiResolutionMinValue(); } +extern "C" int vtk_capsule_source_get_phi_resolution_max_value(vtkCapsuleSource* sself) { return sself->GetPhiResolutionMaxValue(); } +extern "C" int vtk_capsule_source_get_phi_resolution(vtkCapsuleSource* sself) { return sself->GetPhiResolution(); } +extern "C" void vtk_capsule_source_set_lat_long_tessellation(vtkCapsuleSource* sself, int _arg) { sself->SetLatLongTessellation(_arg); } +extern "C" int vtk_capsule_source_get_lat_long_tessellation(vtkCapsuleSource* sself) { return sself->GetLatLongTessellation(); } +extern "C" void vtk_capsule_source_lat_long_tessellation_on(vtkCapsuleSource* sself) { sself->LatLongTessellationOn(); } +extern "C" void vtk_capsule_source_lat_long_tessellation_off(vtkCapsuleSource* sself) { sself->LatLongTessellationOff(); } +extern "C" void vtk_capsule_source_set_output_points_precision(vtkCapsuleSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_capsule_source_get_output_points_precision(vtkCapsuleSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkCellTypeSource * vtkCellTypeSource_new () {return vtkCellTypeSource :: New () ;} +extern "C" void vtkCellTypeSource_destructor (vtkCellTypeSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cell_type_source_set_cell_type(vtkCellTypeSource* sself, int cellType) { sself->SetCellType(cellType); } +extern "C" int vtk_cell_type_source_get_cell_type(vtkCellTypeSource* sself) { return sself->GetCellType(); } +extern "C" void vtk_cell_type_source_set_cell_order(vtkCellTypeSource* sself, int _arg) { sself->SetCellOrder(_arg); } +extern "C" int vtk_cell_type_source_get_cell_order(vtkCellTypeSource* sself) { return sself->GetCellOrder(); } +extern "C" void vtk_cell_type_source_set_complete_quadratic_simplicial_elements(vtkCellTypeSource* sself, bool _arg) { sself->SetCompleteQuadraticSimplicialElements(_arg); } +extern "C" bool vtk_cell_type_source_get_complete_quadratic_simplicial_elements(vtkCellTypeSource* sself) { return sself->GetCompleteQuadraticSimplicialElements(); } +extern "C" void vtk_cell_type_source_complete_quadratic_simplicial_elements_on(vtkCellTypeSource* sself) { sself->CompleteQuadraticSimplicialElementsOn(); } +extern "C" void vtk_cell_type_source_complete_quadratic_simplicial_elements_off(vtkCellTypeSource* sself) { sself->CompleteQuadraticSimplicialElementsOff(); } +extern "C" void vtk_cell_type_source_set_polynomial_field_order(vtkCellTypeSource* sself, int _arg) { sself->SetPolynomialFieldOrder(_arg); } +extern "C" int vtk_cell_type_source_get_polynomial_field_order_min_value(vtkCellTypeSource* sself) { return sself->GetPolynomialFieldOrderMinValue(); } +extern "C" int vtk_cell_type_source_get_polynomial_field_order_max_value(vtkCellTypeSource* sself) { return sself->GetPolynomialFieldOrderMaxValue(); } +extern "C" int vtk_cell_type_source_get_polynomial_field_order(vtkCellTypeSource* sself) { return sself->GetPolynomialFieldOrder(); } +extern "C" int vtk_cell_type_source_get_cell_dimension(vtkCellTypeSource* sself) { return sself->GetCellDimension(); } +extern "C" void vtk_cell_type_source_set_output_precision(vtkCellTypeSource* sself, int _arg) { sself->SetOutputPrecision(_arg); } +extern "C" int vtk_cell_type_source_get_output_precision_min_value(vtkCellTypeSource* sself) { return sself->GetOutputPrecisionMinValue(); } +extern "C" int vtk_cell_type_source_get_output_precision_max_value(vtkCellTypeSource* sself) { return sself->GetOutputPrecisionMaxValue(); } +extern "C" int vtk_cell_type_source_get_output_precision(vtkCellTypeSource* sself) { return sself->GetOutputPrecision(); } +extern "C" vtkConeSource * vtkConeSource_new () {return vtkConeSource :: New () ;} +extern "C" void vtkConeSource_destructor (vtkConeSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cone_source_set_height(vtkConeSource* sself, double _arg) { sself->SetHeight(_arg); } +extern "C" double vtk_cone_source_get_height_min_value(vtkConeSource* sself) { return sself->GetHeightMinValue(); } +extern "C" double vtk_cone_source_get_height_max_value(vtkConeSource* sself) { return sself->GetHeightMaxValue(); } +extern "C" double vtk_cone_source_get_height(vtkConeSource* sself) { return sself->GetHeight(); } +extern "C" void vtk_cone_source_set_radius(vtkConeSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_cone_source_get_radius_min_value(vtkConeSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_cone_source_get_radius_max_value(vtkConeSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_cone_source_get_radius(vtkConeSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_cone_source_set_resolution(vtkConeSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_cone_source_get_resolution_min_value(vtkConeSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_cone_source_get_resolution_max_value(vtkConeSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_cone_source_get_resolution(vtkConeSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_cone_source_set_center(vtkConeSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cone_source_set_direction(vtkConeSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetDirection(_arg1, _arg2, _arg3); } +extern "C" void vtk_cone_source_set_angle(vtkConeSource* sself, double angle) { sself->SetAngle(angle); } +extern "C" double vtk_cone_source_get_angle(vtkConeSource* sself) { return sself->GetAngle(); } +extern "C" void vtk_cone_source_set_capping(vtkConeSource* sself, int _arg) { sself->SetCapping(_arg); } +extern "C" int vtk_cone_source_get_capping(vtkConeSource* sself) { return sself->GetCapping(); } +extern "C" void vtk_cone_source_capping_on(vtkConeSource* sself) { sself->CappingOn(); } +extern "C" void vtk_cone_source_capping_off(vtkConeSource* sself) { sself->CappingOff(); } +extern "C" void vtk_cone_source_set_output_points_precision(vtkConeSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_cone_source_get_output_points_precision(vtkConeSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkCubeSource * vtkCubeSource_new () {return vtkCubeSource :: New () ;} +extern "C" void vtkCubeSource_destructor (vtkCubeSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cube_source_set_x_length(vtkCubeSource* sself, double _arg) { sself->SetXLength(_arg); } +extern "C" double vtk_cube_source_get_x_length_min_value(vtkCubeSource* sself) { return sself->GetXLengthMinValue(); } +extern "C" double vtk_cube_source_get_x_length_max_value(vtkCubeSource* sself) { return sself->GetXLengthMaxValue(); } +extern "C" double vtk_cube_source_get_x_length(vtkCubeSource* sself) { return sself->GetXLength(); } +extern "C" void vtk_cube_source_set_y_length(vtkCubeSource* sself, double _arg) { sself->SetYLength(_arg); } +extern "C" double vtk_cube_source_get_y_length_min_value(vtkCubeSource* sself) { return sself->GetYLengthMinValue(); } +extern "C" double vtk_cube_source_get_y_length_max_value(vtkCubeSource* sself) { return sself->GetYLengthMaxValue(); } +extern "C" double vtk_cube_source_get_y_length(vtkCubeSource* sself) { return sself->GetYLength(); } +extern "C" void vtk_cube_source_set_z_length(vtkCubeSource* sself, double _arg) { sself->SetZLength(_arg); } +extern "C" double vtk_cube_source_get_z_length_min_value(vtkCubeSource* sself) { return sself->GetZLengthMinValue(); } +extern "C" double vtk_cube_source_get_z_length_max_value(vtkCubeSource* sself) { return sself->GetZLengthMaxValue(); } +extern "C" double vtk_cube_source_get_z_length(vtkCubeSource* sself) { return sself->GetZLength(); } +extern "C" void vtk_cube_source_set_center(vtkCubeSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cube_source_set_bounds(vtkCubeSource* sself, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) { sself->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax); } +extern "C" void vtk_cube_source_set_output_points_precision(vtkCubeSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_cube_source_get_output_points_precision(vtkCubeSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkCylinderSource * vtkCylinderSource_new () {return vtkCylinderSource :: New () ;} +extern "C" void vtkCylinderSource_destructor (vtkCylinderSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_cylinder_source_set_height(vtkCylinderSource* sself, double _arg) { sself->SetHeight(_arg); } +extern "C" double vtk_cylinder_source_get_height_min_value(vtkCylinderSource* sself) { return sself->GetHeightMinValue(); } +extern "C" double vtk_cylinder_source_get_height_max_value(vtkCylinderSource* sself) { return sself->GetHeightMaxValue(); } +extern "C" double vtk_cylinder_source_get_height(vtkCylinderSource* sself) { return sself->GetHeight(); } +extern "C" void vtk_cylinder_source_set_radius(vtkCylinderSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_cylinder_source_get_radius_min_value(vtkCylinderSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_cylinder_source_get_radius_max_value(vtkCylinderSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_cylinder_source_get_radius(vtkCylinderSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_cylinder_source_set_center(vtkCylinderSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_cylinder_source_set_resolution(vtkCylinderSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_cylinder_source_get_resolution_min_value(vtkCylinderSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_cylinder_source_get_resolution_max_value(vtkCylinderSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_cylinder_source_get_resolution(vtkCylinderSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_cylinder_source_set_capping(vtkCylinderSource* sself, int _arg) { sself->SetCapping(_arg); } +extern "C" int vtk_cylinder_source_get_capping(vtkCylinderSource* sself) { return sself->GetCapping(); } +extern "C" void vtk_cylinder_source_capping_on(vtkCylinderSource* sself) { sself->CappingOn(); } +extern "C" void vtk_cylinder_source_capping_off(vtkCylinderSource* sself) { sself->CappingOff(); } +extern "C" void vtk_cylinder_source_set_output_points_precision(vtkCylinderSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_cylinder_source_get_output_points_precision(vtkCylinderSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkDiagonalMatrixSource * vtkDiagonalMatrixSource_new () {return vtkDiagonalMatrixSource :: New () ;} +extern "C" void vtkDiagonalMatrixSource_destructor (vtkDiagonalMatrixSource * sself) {sself -> Delete () ; return ;} +extern "C" int vtk_diagonal_matrix_source_get_array_type(vtkDiagonalMatrixSource* sself) { return sself->GetArrayType(); } +extern "C" void vtk_diagonal_matrix_source_set_array_type(vtkDiagonalMatrixSource* sself, int _arg) { sself->SetArrayType(_arg); } +extern "C" long long vtk_diagonal_matrix_source_get_extents(vtkDiagonalMatrixSource* sself) { return sself->GetExtents(); } +extern "C" void vtk_diagonal_matrix_source_set_extents(vtkDiagonalMatrixSource* sself, long long _arg) { sself->SetExtents(_arg); } +extern "C" double vtk_diagonal_matrix_source_get_diagonal(vtkDiagonalMatrixSource* sself) { return sself->GetDiagonal(); } +extern "C" void vtk_diagonal_matrix_source_set_diagonal(vtkDiagonalMatrixSource* sself, double _arg) { sself->SetDiagonal(_arg); } +extern "C" double vtk_diagonal_matrix_source_get_super_diagonal(vtkDiagonalMatrixSource* sself) { return sself->GetSuperDiagonal(); } +extern "C" void vtk_diagonal_matrix_source_set_super_diagonal(vtkDiagonalMatrixSource* sself, double _arg) { sself->SetSuperDiagonal(_arg); } +extern "C" double vtk_diagonal_matrix_source_get_sub_diagonal(vtkDiagonalMatrixSource* sself) { return sself->GetSubDiagonal(); } +extern "C" void vtk_diagonal_matrix_source_set_sub_diagonal(vtkDiagonalMatrixSource* sself, double _arg) { sself->SetSubDiagonal(_arg); } +extern "C" void vtk_diagonal_matrix_source_set_row_label(vtkDiagonalMatrixSource* sself, const char* _arg) { sself->SetRowLabel(_arg); } +extern "C" void vtk_diagonal_matrix_source_set_column_label(vtkDiagonalMatrixSource* sself, const char* _arg) { sself->SetColumnLabel(_arg); } +extern "C" vtkDiskSource * vtkDiskSource_new () {return vtkDiskSource :: New () ;} +extern "C" void vtkDiskSource_destructor (vtkDiskSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_disk_source_set_inner_radius(vtkDiskSource* sself, double _arg) { sself->SetInnerRadius(_arg); } +extern "C" double vtk_disk_source_get_inner_radius_min_value(vtkDiskSource* sself) { return sself->GetInnerRadiusMinValue(); } +extern "C" double vtk_disk_source_get_inner_radius_max_value(vtkDiskSource* sself) { return sself->GetInnerRadiusMaxValue(); } +extern "C" double vtk_disk_source_get_inner_radius(vtkDiskSource* sself) { return sself->GetInnerRadius(); } +extern "C" void vtk_disk_source_set_outer_radius(vtkDiskSource* sself, double _arg) { sself->SetOuterRadius(_arg); } +extern "C" double vtk_disk_source_get_outer_radius_min_value(vtkDiskSource* sself) { return sself->GetOuterRadiusMinValue(); } +extern "C" double vtk_disk_source_get_outer_radius_max_value(vtkDiskSource* sself) { return sself->GetOuterRadiusMaxValue(); } +extern "C" double vtk_disk_source_get_outer_radius(vtkDiskSource* sself) { return sself->GetOuterRadius(); } +extern "C" void vtk_disk_source_set_radial_resolution(vtkDiskSource* sself, int _arg) { sself->SetRadialResolution(_arg); } +extern "C" int vtk_disk_source_get_radial_resolution_min_value(vtkDiskSource* sself) { return sself->GetRadialResolutionMinValue(); } +extern "C" int vtk_disk_source_get_radial_resolution_max_value(vtkDiskSource* sself) { return sself->GetRadialResolutionMaxValue(); } +extern "C" int vtk_disk_source_get_radial_resolution(vtkDiskSource* sself) { return sself->GetRadialResolution(); } +extern "C" void vtk_disk_source_set_circumferential_resolution(vtkDiskSource* sself, int _arg) { sself->SetCircumferentialResolution(_arg); } +extern "C" int vtk_disk_source_get_circumferential_resolution_min_value(vtkDiskSource* sself) { return sself->GetCircumferentialResolutionMinValue(); } +extern "C" int vtk_disk_source_get_circumferential_resolution_max_value(vtkDiskSource* sself) { return sself->GetCircumferentialResolutionMaxValue(); } +extern "C" int vtk_disk_source_get_circumferential_resolution(vtkDiskSource* sself) { return sself->GetCircumferentialResolution(); } +extern "C" void vtk_disk_source_set_output_points_precision(vtkDiskSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_disk_source_get_output_points_precision(vtkDiskSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkEllipseArcSource * vtkEllipseArcSource_new () {return vtkEllipseArcSource :: New () ;} +extern "C" void vtkEllipseArcSource_destructor (vtkEllipseArcSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_ellipse_arc_source_set_center(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_ellipse_arc_source_set_normal(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_ellipse_arc_source_set_major_radius_vector(vtkEllipseArcSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetMajorRadiusVector(_arg1, _arg2, _arg3); } +extern "C" void vtk_ellipse_arc_source_set_start_angle(vtkEllipseArcSource* sself, double _arg) { sself->SetStartAngle(_arg); } +extern "C" double vtk_ellipse_arc_source_get_start_angle_min_value(vtkEllipseArcSource* sself) { return sself->GetStartAngleMinValue(); } +extern "C" double vtk_ellipse_arc_source_get_start_angle_max_value(vtkEllipseArcSource* sself) { return sself->GetStartAngleMaxValue(); } +extern "C" double vtk_ellipse_arc_source_get_start_angle(vtkEllipseArcSource* sself) { return sself->GetStartAngle(); } +extern "C" void vtk_ellipse_arc_source_set_segment_angle(vtkEllipseArcSource* sself, double _arg) { sself->SetSegmentAngle(_arg); } +extern "C" double vtk_ellipse_arc_source_get_segment_angle_min_value(vtkEllipseArcSource* sself) { return sself->GetSegmentAngleMinValue(); } +extern "C" double vtk_ellipse_arc_source_get_segment_angle_max_value(vtkEllipseArcSource* sself) { return sself->GetSegmentAngleMaxValue(); } +extern "C" double vtk_ellipse_arc_source_get_segment_angle(vtkEllipseArcSource* sself) { return sself->GetSegmentAngle(); } +extern "C" void vtk_ellipse_arc_source_set_resolution(vtkEllipseArcSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_ellipse_arc_source_get_resolution_min_value(vtkEllipseArcSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_ellipse_arc_source_get_resolution_max_value(vtkEllipseArcSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_ellipse_arc_source_get_resolution(vtkEllipseArcSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_ellipse_arc_source_set_close(vtkEllipseArcSource* sself, bool _arg) { sself->SetClose(_arg); } +extern "C" bool vtk_ellipse_arc_source_get_close(vtkEllipseArcSource* sself) { return sself->GetClose(); } +extern "C" void vtk_ellipse_arc_source_close_on(vtkEllipseArcSource* sself) { sself->CloseOn(); } +extern "C" void vtk_ellipse_arc_source_close_off(vtkEllipseArcSource* sself) { sself->CloseOff(); } +extern "C" void vtk_ellipse_arc_source_set_output_points_precision(vtkEllipseArcSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_ellipse_arc_source_get_output_points_precision(vtkEllipseArcSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" void vtk_ellipse_arc_source_set_ratio(vtkEllipseArcSource* sself, double _arg) { sself->SetRatio(_arg); } +extern "C" double vtk_ellipse_arc_source_get_ratio_min_value(vtkEllipseArcSource* sself) { return sself->GetRatioMinValue(); } +extern "C" double vtk_ellipse_arc_source_get_ratio_max_value(vtkEllipseArcSource* sself) { return sself->GetRatioMaxValue(); } +extern "C" double vtk_ellipse_arc_source_get_ratio(vtkEllipseArcSource* sself) { return sself->GetRatio(); } +extern "C" vtkEllipticalButtonSource * vtkEllipticalButtonSource_new () {return vtkEllipticalButtonSource :: New () ;} +extern "C" void vtkEllipticalButtonSource_destructor (vtkEllipticalButtonSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_elliptical_button_source_set_width(vtkEllipticalButtonSource* sself, double _arg) { sself->SetWidth(_arg); } +extern "C" double vtk_elliptical_button_source_get_width_min_value(vtkEllipticalButtonSource* sself) { return sself->GetWidthMinValue(); } +extern "C" double vtk_elliptical_button_source_get_width_max_value(vtkEllipticalButtonSource* sself) { return sself->GetWidthMaxValue(); } +extern "C" double vtk_elliptical_button_source_get_width(vtkEllipticalButtonSource* sself) { return sself->GetWidth(); } +extern "C" void vtk_elliptical_button_source_set_height(vtkEllipticalButtonSource* sself, double _arg) { sself->SetHeight(_arg); } +extern "C" double vtk_elliptical_button_source_get_height_min_value(vtkEllipticalButtonSource* sself) { return sself->GetHeightMinValue(); } +extern "C" double vtk_elliptical_button_source_get_height_max_value(vtkEllipticalButtonSource* sself) { return sself->GetHeightMaxValue(); } +extern "C" double vtk_elliptical_button_source_get_height(vtkEllipticalButtonSource* sself) { return sself->GetHeight(); } +extern "C" void vtk_elliptical_button_source_set_depth(vtkEllipticalButtonSource* sself, double _arg) { sself->SetDepth(_arg); } +extern "C" double vtk_elliptical_button_source_get_depth_min_value(vtkEllipticalButtonSource* sself) { return sself->GetDepthMinValue(); } +extern "C" double vtk_elliptical_button_source_get_depth_max_value(vtkEllipticalButtonSource* sself) { return sself->GetDepthMaxValue(); } +extern "C" double vtk_elliptical_button_source_get_depth(vtkEllipticalButtonSource* sself) { return sself->GetDepth(); } +extern "C" void vtk_elliptical_button_source_set_circumferential_resolution(vtkEllipticalButtonSource* sself, int _arg) { sself->SetCircumferentialResolution(_arg); } +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution_min_value(vtkEllipticalButtonSource* sself) { return sself->GetCircumferentialResolutionMinValue(); } +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution_max_value(vtkEllipticalButtonSource* sself) { return sself->GetCircumferentialResolutionMaxValue(); } +extern "C" int vtk_elliptical_button_source_get_circumferential_resolution(vtkEllipticalButtonSource* sself) { return sself->GetCircumferentialResolution(); } +extern "C" void vtk_elliptical_button_source_set_texture_resolution(vtkEllipticalButtonSource* sself, int _arg) { sself->SetTextureResolution(_arg); } +extern "C" int vtk_elliptical_button_source_get_texture_resolution_min_value(vtkEllipticalButtonSource* sself) { return sself->GetTextureResolutionMinValue(); } +extern "C" int vtk_elliptical_button_source_get_texture_resolution_max_value(vtkEllipticalButtonSource* sself) { return sself->GetTextureResolutionMaxValue(); } +extern "C" int vtk_elliptical_button_source_get_texture_resolution(vtkEllipticalButtonSource* sself) { return sself->GetTextureResolution(); } +extern "C" void vtk_elliptical_button_source_set_shoulder_resolution(vtkEllipticalButtonSource* sself, int _arg) { sself->SetShoulderResolution(_arg); } +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution_min_value(vtkEllipticalButtonSource* sself) { return sself->GetShoulderResolutionMinValue(); } +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution_max_value(vtkEllipticalButtonSource* sself) { return sself->GetShoulderResolutionMaxValue(); } +extern "C" int vtk_elliptical_button_source_get_shoulder_resolution(vtkEllipticalButtonSource* sself) { return sself->GetShoulderResolution(); } +extern "C" void vtk_elliptical_button_source_set_radial_ratio(vtkEllipticalButtonSource* sself, double _arg) { sself->SetRadialRatio(_arg); } +extern "C" double vtk_elliptical_button_source_get_radial_ratio_min_value(vtkEllipticalButtonSource* sself) { return sself->GetRadialRatioMinValue(); } +extern "C" double vtk_elliptical_button_source_get_radial_ratio_max_value(vtkEllipticalButtonSource* sself) { return sself->GetRadialRatioMaxValue(); } +extern "C" double vtk_elliptical_button_source_get_radial_ratio(vtkEllipticalButtonSource* sself) { return sself->GetRadialRatio(); } +extern "C" void vtk_elliptical_button_source_set_output_points_precision(vtkEllipticalButtonSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_elliptical_button_source_get_output_points_precision(vtkEllipticalButtonSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkFrustumSource * vtkFrustumSource_new () {return vtkFrustumSource :: New () ;} +extern "C" void vtkFrustumSource_destructor (vtkFrustumSource * sself) {sself -> Delete () ; return ;} +extern "C" bool vtk_frustum_source_get_show_lines(vtkFrustumSource* sself) { return sself->GetShowLines(); } +extern "C" void vtk_frustum_source_set_show_lines(vtkFrustumSource* sself, bool _arg) { sself->SetShowLines(_arg); } +extern "C" void vtk_frustum_source_show_lines_on(vtkFrustumSource* sself) { sself->ShowLinesOn(); } +extern "C" void vtk_frustum_source_show_lines_off(vtkFrustumSource* sself) { sself->ShowLinesOff(); } +extern "C" double vtk_frustum_source_get_lines_length(vtkFrustumSource* sself) { return sself->GetLinesLength(); } +extern "C" void vtk_frustum_source_set_lines_length(vtkFrustumSource* sself, double _arg) { sself->SetLinesLength(_arg); } +extern "C" unsigned long vtk_frustum_source_get_m_time(vtkFrustumSource* sself) { return sself->GetMTime(); } +extern "C" void vtk_frustum_source_set_output_points_precision(vtkFrustumSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_frustum_source_get_output_points_precision(vtkFrustumSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkGlyphSource2D * vtkGlyphSource2D_new () {return vtkGlyphSource2D :: New () ;} +extern "C" void vtkGlyphSource2D_destructor (vtkGlyphSource2D * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_glyph_source_2_d_set_center(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_glyph_source_2_d_set_scale(vtkGlyphSource2D* sself, double _arg) { sself->SetScale(_arg); } +extern "C" double vtk_glyph_source_2_d_get_scale_min_value(vtkGlyphSource2D* sself) { return sself->GetScaleMinValue(); } +extern "C" double vtk_glyph_source_2_d_get_scale_max_value(vtkGlyphSource2D* sself) { return sself->GetScaleMaxValue(); } +extern "C" double vtk_glyph_source_2_d_get_scale(vtkGlyphSource2D* sself) { return sself->GetScale(); } +extern "C" void vtk_glyph_source_2_d_set_scale_2(vtkGlyphSource2D* sself, double _arg) { sself->SetScale2(_arg); } +extern "C" double vtk_glyph_source_2_d_get_scale_2_min_value(vtkGlyphSource2D* sself) { return sself->GetScale2MinValue(); } +extern "C" double vtk_glyph_source_2_d_get_scale_2_max_value(vtkGlyphSource2D* sself) { return sself->GetScale2MaxValue(); } +extern "C" double vtk_glyph_source_2_d_get_scale_2(vtkGlyphSource2D* sself) { return sself->GetScale2(); } +extern "C" void vtk_glyph_source_2_d_set_color(vtkGlyphSource2D* sself, double _arg1, double _arg2, double _arg3) { sself->SetColor(_arg1, _arg2, _arg3); } +extern "C" void vtk_glyph_source_2_d_set_filled(vtkGlyphSource2D* sself, int _arg) { sself->SetFilled(_arg); } +extern "C" int vtk_glyph_source_2_d_get_filled(vtkGlyphSource2D* sself) { return sself->GetFilled(); } +extern "C" void vtk_glyph_source_2_d_filled_on(vtkGlyphSource2D* sself) { sself->FilledOn(); } +extern "C" void vtk_glyph_source_2_d_filled_off(vtkGlyphSource2D* sself) { sself->FilledOff(); } +extern "C" void vtk_glyph_source_2_d_set_dash(vtkGlyphSource2D* sself, int _arg) { sself->SetDash(_arg); } +extern "C" int vtk_glyph_source_2_d_get_dash(vtkGlyphSource2D* sself) { return sself->GetDash(); } +extern "C" void vtk_glyph_source_2_d_dash_on(vtkGlyphSource2D* sself) { sself->DashOn(); } +extern "C" void vtk_glyph_source_2_d_dash_off(vtkGlyphSource2D* sself) { sself->DashOff(); } +extern "C" void vtk_glyph_source_2_d_set_cross(vtkGlyphSource2D* sself, int _arg) { sself->SetCross(_arg); } +extern "C" int vtk_glyph_source_2_d_get_cross(vtkGlyphSource2D* sself) { return sself->GetCross(); } +extern "C" void vtk_glyph_source_2_d_cross_on(vtkGlyphSource2D* sself) { sself->CrossOn(); } +extern "C" void vtk_glyph_source_2_d_cross_off(vtkGlyphSource2D* sself) { sself->CrossOff(); } +extern "C" void vtk_glyph_source_2_d_set_rotation_angle(vtkGlyphSource2D* sself, double _arg) { sself->SetRotationAngle(_arg); } +extern "C" double vtk_glyph_source_2_d_get_rotation_angle(vtkGlyphSource2D* sself) { return sself->GetRotationAngle(); } +extern "C" void vtk_glyph_source_2_d_set_resolution(vtkGlyphSource2D* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_glyph_source_2_d_get_resolution_min_value(vtkGlyphSource2D* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_glyph_source_2_d_get_resolution_max_value(vtkGlyphSource2D* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_glyph_source_2_d_get_resolution(vtkGlyphSource2D* sself) { return sself->GetResolution(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type(vtkGlyphSource2D* sself, int _arg) { sself->SetGlyphType(_arg); } +extern "C" int vtk_glyph_source_2_d_get_glyph_type_min_value(vtkGlyphSource2D* sself) { return sself->GetGlyphTypeMinValue(); } +extern "C" int vtk_glyph_source_2_d_get_glyph_type_max_value(vtkGlyphSource2D* sself) { return sself->GetGlyphTypeMaxValue(); } +extern "C" int vtk_glyph_source_2_d_get_glyph_type(vtkGlyphSource2D* sself) { return sself->GetGlyphType(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_none(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToNone(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_vertex(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToVertex(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_dash(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToDash(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_cross(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToCross(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_thick_cross(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToThickCross(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_triangle(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToTriangle(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_square(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToSquare(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_circle(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToCircle(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_diamond(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToDiamond(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_arrow(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToArrow(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_thick_arrow(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToThickArrow(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_hooked_arrow(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToHookedArrow(); } +extern "C" void vtk_glyph_source_2_d_set_glyph_type_to_edge_arrow(vtkGlyphSource2D* sself) { sself->SetGlyphTypeToEdgeArrow(); } +extern "C" void vtk_glyph_source_2_d_set_output_points_precision(vtkGlyphSource2D* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_glyph_source_2_d_get_output_points_precision(vtkGlyphSource2D* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkGraphToPolyData * vtkGraphToPolyData_new () {return vtkGraphToPolyData :: New () ;} +extern "C" void vtkGraphToPolyData_destructor (vtkGraphToPolyData * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_graph_to_poly_data_set_edge_glyph_output(vtkGraphToPolyData* sself, bool _arg) { sself->SetEdgeGlyphOutput(_arg); } +extern "C" bool vtk_graph_to_poly_data_get_edge_glyph_output(vtkGraphToPolyData* sself) { return sself->GetEdgeGlyphOutput(); } +extern "C" void vtk_graph_to_poly_data_edge_glyph_output_on(vtkGraphToPolyData* sself) { sself->EdgeGlyphOutputOn(); } +extern "C" void vtk_graph_to_poly_data_edge_glyph_output_off(vtkGraphToPolyData* sself) { sself->EdgeGlyphOutputOff(); } +extern "C" void vtk_graph_to_poly_data_set_edge_glyph_position(vtkGraphToPolyData* sself, double _arg) { sself->SetEdgeGlyphPosition(_arg); } +extern "C" double vtk_graph_to_poly_data_get_edge_glyph_position(vtkGraphToPolyData* sself) { return sself->GetEdgeGlyphPosition(); } +extern "C" vtkHyperTreeGridSource * vtkHyperTreeGridSource_new () {return vtkHyperTreeGridSource :: New () ;} +extern "C" void vtkHyperTreeGridSource_destructor (vtkHyperTreeGridSource * sself) {sself -> Delete () ; return ;} +extern "C" unsigned int vtk_hyper_tree_grid_source_get_maximum_level(vtkHyperTreeGridSource* sself) { return sself->GetMaximumLevel(); } +extern "C" void vtk_hyper_tree_grid_source_set_maximum_level(vtkHyperTreeGridSource* sself, unsigned int levels) { sself->SetMaximumLevel(levels); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_max_depth(vtkHyperTreeGridSource* sself) { return sself->GetMaxDepth(); } +extern "C" void vtk_hyper_tree_grid_source_set_max_depth(vtkHyperTreeGridSource* sself, unsigned int levels) { sself->SetMaxDepth(levels); } +extern "C" void vtk_hyper_tree_grid_source_set_origin(vtkHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_hyper_tree_grid_source_set_grid_scale(vtkHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetGridScale(_arg1, _arg2, _arg3); } +extern "C" void vtk_hyper_tree_grid_source_set_transposed_root_indexing(vtkHyperTreeGridSource* sself, bool _arg) { sself->SetTransposedRootIndexing(_arg); } +extern "C" bool vtk_hyper_tree_grid_source_get_transposed_root_indexing(vtkHyperTreeGridSource* sself) { return sself->GetTransposedRootIndexing(); } +extern "C" void vtk_hyper_tree_grid_source_set_indexing_mode_to_kji(vtkHyperTreeGridSource* sself) { sself->SetIndexingModeToKJI(); } +extern "C" void vtk_hyper_tree_grid_source_set_indexing_mode_to_ijk(vtkHyperTreeGridSource* sself) { sself->SetIndexingModeToIJK(); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_orientation(vtkHyperTreeGridSource* sself) { return sself->GetOrientation(); } +extern "C" void vtk_hyper_tree_grid_source_set_branch_factor(vtkHyperTreeGridSource* sself, unsigned int _arg) { sself->SetBranchFactor(_arg); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor_min_value(vtkHyperTreeGridSource* sself) { return sself->GetBranchFactorMinValue(); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor_max_value(vtkHyperTreeGridSource* sself) { return sself->GetBranchFactorMaxValue(); } +extern "C" unsigned int vtk_hyper_tree_grid_source_get_branch_factor(vtkHyperTreeGridSource* sself) { return sself->GetBranchFactor(); } +extern "C" void vtk_hyper_tree_grid_source_set_use_descriptor(vtkHyperTreeGridSource* sself, bool _arg) { sself->SetUseDescriptor(_arg); } +extern "C" bool vtk_hyper_tree_grid_source_get_use_descriptor(vtkHyperTreeGridSource* sself) { return sself->GetUseDescriptor(); } +extern "C" void vtk_hyper_tree_grid_source_use_descriptor_on(vtkHyperTreeGridSource* sself) { sself->UseDescriptorOn(); } +extern "C" void vtk_hyper_tree_grid_source_use_descriptor_off(vtkHyperTreeGridSource* sself) { sself->UseDescriptorOff(); } +extern "C" void vtk_hyper_tree_grid_source_set_use_mask(vtkHyperTreeGridSource* sself, bool _arg) { sself->SetUseMask(_arg); } +extern "C" bool vtk_hyper_tree_grid_source_get_use_mask(vtkHyperTreeGridSource* sself) { return sself->GetUseMask(); } +extern "C" void vtk_hyper_tree_grid_source_use_mask_on(vtkHyperTreeGridSource* sself) { sself->UseMaskOn(); } +extern "C" void vtk_hyper_tree_grid_source_use_mask_off(vtkHyperTreeGridSource* sself) { sself->UseMaskOff(); } +extern "C" void vtk_hyper_tree_grid_source_set_generate_interface_fields(vtkHyperTreeGridSource* sself, bool _arg) { sself->SetGenerateInterfaceFields(_arg); } +extern "C" bool vtk_hyper_tree_grid_source_get_generate_interface_fields(vtkHyperTreeGridSource* sself) { return sself->GetGenerateInterfaceFields(); } +extern "C" void vtk_hyper_tree_grid_source_generate_interface_fields_on(vtkHyperTreeGridSource* sself) { sself->GenerateInterfaceFieldsOn(); } +extern "C" void vtk_hyper_tree_grid_source_generate_interface_fields_off(vtkHyperTreeGridSource* sself) { sself->GenerateInterfaceFieldsOff(); } +extern "C" void vtk_hyper_tree_grid_source_set_descriptor(vtkHyperTreeGridSource* sself, const char* _arg) { sself->SetDescriptor(_arg); } +extern "C" void vtk_hyper_tree_grid_source_set_mask(vtkHyperTreeGridSource* sself, const char* _arg) { sself->SetMask(_arg); } +extern "C" unsigned long vtk_hyper_tree_grid_source_get_m_time(vtkHyperTreeGridSource* sself) { return sself->GetMTime(); } +extern "C" vtkLineSource * vtkLineSource_new () {return vtkLineSource :: New () ;} +extern "C" void vtkLineSource_destructor (vtkLineSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_line_source_set_point_1(vtkLineSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint1(_arg1, _arg2, _arg3); } +extern "C" void vtk_line_source_set_point_2(vtkLineSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetPoint2(_arg1, _arg2, _arg3); } +extern "C" void vtk_line_source_set_use_regular_refinement(vtkLineSource* sself, bool _arg) { sself->SetUseRegularRefinement(_arg); } +extern "C" bool vtk_line_source_get_use_regular_refinement(vtkLineSource* sself) { return sself->GetUseRegularRefinement(); } +extern "C" void vtk_line_source_use_regular_refinement_on(vtkLineSource* sself) { sself->UseRegularRefinementOn(); } +extern "C" void vtk_line_source_use_regular_refinement_off(vtkLineSource* sself) { sself->UseRegularRefinementOff(); } +extern "C" void vtk_line_source_set_resolution(vtkLineSource* sself, int _arg) { sself->SetResolution(_arg); } +extern "C" int vtk_line_source_get_resolution_min_value(vtkLineSource* sself) { return sself->GetResolutionMinValue(); } +extern "C" int vtk_line_source_get_resolution_max_value(vtkLineSource* sself) { return sself->GetResolutionMaxValue(); } +extern "C" int vtk_line_source_get_resolution(vtkLineSource* sself) { return sself->GetResolution(); } +extern "C" void vtk_line_source_set_number_of_refinement_ratios(vtkLineSource* sself, int p0) { sself->SetNumberOfRefinementRatios(p0); } +extern "C" void vtk_line_source_set_refinement_ratio(vtkLineSource* sself, int index, double value) { sself->SetRefinementRatio(index, value); } +extern "C" int vtk_line_source_get_number_of_refinement_ratios(vtkLineSource* sself) { return sself->GetNumberOfRefinementRatios(); } +extern "C" double vtk_line_source_get_refinement_ratio(vtkLineSource* sself, int index) { return sself->GetRefinementRatio(index); } +extern "C" void vtk_line_source_set_output_points_precision(vtkLineSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_line_source_get_output_points_precision(vtkLineSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkOutlineCornerFilter * vtkOutlineCornerFilter_new () {return vtkOutlineCornerFilter :: New () ;} +extern "C" void vtkOutlineCornerFilter_destructor (vtkOutlineCornerFilter * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_outline_corner_filter_set_corner_factor(vtkOutlineCornerFilter* sself, double _arg) { sself->SetCornerFactor(_arg); } +extern "C" double vtk_outline_corner_filter_get_corner_factor_min_value(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactorMinValue(); } +extern "C" double vtk_outline_corner_filter_get_corner_factor_max_value(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactorMaxValue(); } +extern "C" double vtk_outline_corner_filter_get_corner_factor(vtkOutlineCornerFilter* sself) { return sself->GetCornerFactor(); } +extern "C" vtkOutlineCornerSource * vtkOutlineCornerSource_new () {return vtkOutlineCornerSource :: New () ;} +extern "C" void vtkOutlineCornerSource_destructor (vtkOutlineCornerSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_outline_corner_source_set_corner_factor(vtkOutlineCornerSource* sself, double _arg) { sself->SetCornerFactor(_arg); } +extern "C" double vtk_outline_corner_source_get_corner_factor_min_value(vtkOutlineCornerSource* sself) { return sself->GetCornerFactorMinValue(); } +extern "C" double vtk_outline_corner_source_get_corner_factor_max_value(vtkOutlineCornerSource* sself) { return sself->GetCornerFactorMaxValue(); } +extern "C" double vtk_outline_corner_source_get_corner_factor(vtkOutlineCornerSource* sself) { return sself->GetCornerFactor(); } +extern "C" vtkOutlineSource * vtkOutlineSource_new () {return vtkOutlineSource :: New () ;} +extern "C" void vtkOutlineSource_destructor (vtkOutlineSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_outline_source_set_box_type(vtkOutlineSource* sself, int _arg) { sself->SetBoxType(_arg); } +extern "C" int vtk_outline_source_get_box_type(vtkOutlineSource* sself) { return sself->GetBoxType(); } +extern "C" void vtk_outline_source_set_box_type_to_axis_aligned(vtkOutlineSource* sself) { sself->SetBoxTypeToAxisAligned(); } +extern "C" void vtk_outline_source_set_box_type_to_oriented(vtkOutlineSource* sself) { sself->SetBoxTypeToOriented(); } +extern "C" void vtk_outline_source_set_bounds(vtkOutlineSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) { sself->SetBounds(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_outline_source_set_generate_faces(vtkOutlineSource* sself, int _arg) { sself->SetGenerateFaces(_arg); } +extern "C" void vtk_outline_source_generate_faces_on(vtkOutlineSource* sself) { sself->GenerateFacesOn(); } +extern "C" void vtk_outline_source_generate_faces_off(vtkOutlineSource* sself) { sself->GenerateFacesOff(); } +extern "C" int vtk_outline_source_get_generate_faces(vtkOutlineSource* sself) { return sself->GetGenerateFaces(); } +extern "C" void vtk_outline_source_set_output_points_precision(vtkOutlineSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_outline_source_get_output_points_precision(vtkOutlineSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkParametricFunctionSource * vtkParametricFunctionSource_new () {return vtkParametricFunctionSource :: New () ;} +extern "C" void vtkParametricFunctionSource_destructor (vtkParametricFunctionSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_parametric_function_source_set_u_resolution(vtkParametricFunctionSource* sself, int _arg) { sself->SetUResolution(_arg); } +extern "C" int vtk_parametric_function_source_get_u_resolution_min_value(vtkParametricFunctionSource* sself) { return sself->GetUResolutionMinValue(); } +extern "C" int vtk_parametric_function_source_get_u_resolution_max_value(vtkParametricFunctionSource* sself) { return sself->GetUResolutionMaxValue(); } +extern "C" int vtk_parametric_function_source_get_u_resolution(vtkParametricFunctionSource* sself) { return sself->GetUResolution(); } +extern "C" void vtk_parametric_function_source_set_v_resolution(vtkParametricFunctionSource* sself, int _arg) { sself->SetVResolution(_arg); } +extern "C" int vtk_parametric_function_source_get_v_resolution_min_value(vtkParametricFunctionSource* sself) { return sself->GetVResolutionMinValue(); } +extern "C" int vtk_parametric_function_source_get_v_resolution_max_value(vtkParametricFunctionSource* sself) { return sself->GetVResolutionMaxValue(); } +extern "C" int vtk_parametric_function_source_get_v_resolution(vtkParametricFunctionSource* sself) { return sself->GetVResolution(); } +extern "C" void vtk_parametric_function_source_set_w_resolution(vtkParametricFunctionSource* sself, int _arg) { sself->SetWResolution(_arg); } +extern "C" int vtk_parametric_function_source_get_w_resolution_min_value(vtkParametricFunctionSource* sself) { return sself->GetWResolutionMinValue(); } +extern "C" int vtk_parametric_function_source_get_w_resolution_max_value(vtkParametricFunctionSource* sself) { return sself->GetWResolutionMaxValue(); } +extern "C" int vtk_parametric_function_source_get_w_resolution(vtkParametricFunctionSource* sself) { return sself->GetWResolution(); } +extern "C" void vtk_parametric_function_source_generate_texture_coordinates_on(vtkParametricFunctionSource* sself) { sself->GenerateTextureCoordinatesOn(); } +extern "C" void vtk_parametric_function_source_generate_texture_coordinates_off(vtkParametricFunctionSource* sself) { sself->GenerateTextureCoordinatesOff(); } +extern "C" void vtk_parametric_function_source_set_generate_texture_coordinates(vtkParametricFunctionSource* sself, int _arg) { sself->SetGenerateTextureCoordinates(_arg); } +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates_min_value(vtkParametricFunctionSource* sself) { return sself->GetGenerateTextureCoordinatesMinValue(); } +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates_max_value(vtkParametricFunctionSource* sself) { return sself->GetGenerateTextureCoordinatesMaxValue(); } +extern "C" int vtk_parametric_function_source_get_generate_texture_coordinates(vtkParametricFunctionSource* sself) { return sself->GetGenerateTextureCoordinates(); } +extern "C" void vtk_parametric_function_source_generate_normals_on(vtkParametricFunctionSource* sself) { sself->GenerateNormalsOn(); } +extern "C" void vtk_parametric_function_source_generate_normals_off(vtkParametricFunctionSource* sself) { sself->GenerateNormalsOff(); } +extern "C" void vtk_parametric_function_source_set_generate_normals(vtkParametricFunctionSource* sself, int _arg) { sself->SetGenerateNormals(_arg); } +extern "C" int vtk_parametric_function_source_get_generate_normals_min_value(vtkParametricFunctionSource* sself) { return sself->GetGenerateNormalsMinValue(); } +extern "C" int vtk_parametric_function_source_get_generate_normals_max_value(vtkParametricFunctionSource* sself) { return sself->GetGenerateNormalsMaxValue(); } +extern "C" int vtk_parametric_function_source_get_generate_normals(vtkParametricFunctionSource* sself) { return sself->GetGenerateNormals(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode(vtkParametricFunctionSource* sself, int _arg) { sself->SetScalarMode(_arg); } +extern "C" int vtk_parametric_function_source_get_scalar_mode_min_value(vtkParametricFunctionSource* sself) { return sself->GetScalarModeMinValue(); } +extern "C" int vtk_parametric_function_source_get_scalar_mode_max_value(vtkParametricFunctionSource* sself) { return sself->GetScalarModeMaxValue(); } +extern "C" int vtk_parametric_function_source_get_scalar_mode(vtkParametricFunctionSource* sself) { return sself->GetScalarMode(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_none(vtkParametricFunctionSource* sself) { sself->SetScalarModeToNone(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u(vtkParametricFunctionSource* sself) { sself->SetScalarModeToU(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_v(vtkParametricFunctionSource* sself) { sself->SetScalarModeToV(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u_0(vtkParametricFunctionSource* sself) { sself->SetScalarModeToU0(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_v_0(vtkParametricFunctionSource* sself) { sself->SetScalarModeToV0(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_u_0_v_0(vtkParametricFunctionSource* sself) { sself->SetScalarModeToU0V0(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_modulus(vtkParametricFunctionSource* sself) { sself->SetScalarModeToModulus(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_phase(vtkParametricFunctionSource* sself) { sself->SetScalarModeToPhase(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_quadrant(vtkParametricFunctionSource* sself) { sself->SetScalarModeToQuadrant(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_x(vtkParametricFunctionSource* sself) { sself->SetScalarModeToX(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_y(vtkParametricFunctionSource* sself) { sself->SetScalarModeToY(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_z(vtkParametricFunctionSource* sself) { sself->SetScalarModeToZ(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_distance(vtkParametricFunctionSource* sself) { sself->SetScalarModeToDistance(); } +extern "C" void vtk_parametric_function_source_set_scalar_mode_to_function_defined(vtkParametricFunctionSource* sself) { sself->SetScalarModeToFunctionDefined(); } +extern "C" unsigned long vtk_parametric_function_source_get_m_time(vtkParametricFunctionSource* sself) { return sself->GetMTime(); } +extern "C" void vtk_parametric_function_source_set_output_points_precision(vtkParametricFunctionSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_parametric_function_source_get_output_points_precision(vtkParametricFunctionSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkPartitionedDataSetCollectionSource * vtkPartitionedDataSetCollectionSource_new () {return vtkPartitionedDataSetCollectionSource :: New () ;} +extern "C" void vtkPartitionedDataSetCollectionSource_destructor (vtkPartitionedDataSetCollectionSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_partitioned_data_set_collection_source_set_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself, int _arg) { sself->SetNumberOfShapes(_arg); } +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapesMinValue(); } +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapesMaxValue(); } +extern "C" int vtk_partitioned_data_set_collection_source_get_number_of_shapes(vtkPartitionedDataSetCollectionSource* sself) { return sself->GetNumberOfShapes(); } +extern "C" vtkPartitionedDataSetSource * vtkPartitionedDataSetSource_new () {return vtkPartitionedDataSetSource :: New () ;} +extern "C" void vtkPartitionedDataSetSource_destructor (vtkPartitionedDataSetSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_partitioned_data_set_source_enable_rank(vtkPartitionedDataSetSource* sself, int rank) { sself->EnableRank(rank); } +extern "C" void vtk_partitioned_data_set_source_enable_all_ranks(vtkPartitionedDataSetSource* sself) { sself->EnableAllRanks(); } +extern "C" void vtk_partitioned_data_set_source_disable_rank(vtkPartitionedDataSetSource* sself, int rank) { sself->DisableRank(rank); } +extern "C" void vtk_partitioned_data_set_source_disable_all_ranks(vtkPartitionedDataSetSource* sself) { sself->DisableAllRanks(); } +extern "C" bool vtk_partitioned_data_set_source_is_enabled_rank(vtkPartitionedDataSetSource* sself, int rank) { return sself->IsEnabledRank(rank); } +extern "C" void vtk_partitioned_data_set_source_set_number_of_partitions(vtkPartitionedDataSetSource* sself, int _arg) { sself->SetNumberOfPartitions(_arg); } +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_min_value(vtkPartitionedDataSetSource* sself) { return sself->GetNumberOfPartitionsMinValue(); } +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions_max_value(vtkPartitionedDataSetSource* sself) { return sself->GetNumberOfPartitionsMaxValue(); } +extern "C" int vtk_partitioned_data_set_source_get_number_of_partitions(vtkPartitionedDataSetSource* sself) { return sself->GetNumberOfPartitions(); } +extern "C" vtkPlaneSource * vtkPlaneSource_new () {return vtkPlaneSource :: New () ;} +extern "C" void vtkPlaneSource_destructor (vtkPlaneSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_plane_source_set_x_resolution(vtkPlaneSource* sself, int _arg) { sself->SetXResolution(_arg); } +extern "C" int vtk_plane_source_get_x_resolution(vtkPlaneSource* sself) { return sself->GetXResolution(); } +extern "C" void vtk_plane_source_set_y_resolution(vtkPlaneSource* sself, int _arg) { sself->SetYResolution(_arg); } +extern "C" int vtk_plane_source_get_y_resolution(vtkPlaneSource* sself) { return sself->GetYResolution(); } +extern "C" void vtk_plane_source_set_resolution(vtkPlaneSource* sself, const int xR, const int yR) { sself->SetResolution(xR, yR); } +extern "C" void vtk_plane_source_get_resolution(vtkPlaneSource* sself, int& xR, int& yR) { sself->GetResolution(xR, yR); } +extern "C" void vtk_plane_source_set_origin(vtkPlaneSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetOrigin(_arg1, _arg2, _arg3); } +extern "C" void vtk_plane_source_set_point_1(vtkPlaneSource* sself, double x, double y, double z) { sself->SetPoint1(x, y, z); } +extern "C" void vtk_plane_source_set_point_2(vtkPlaneSource* sself, double x, double y, double z) { sself->SetPoint2(x, y, z); } +extern "C" void vtk_plane_source_set_center(vtkPlaneSource* sself, double x, double y, double z) { sself->SetCenter(x, y, z); } +extern "C" void vtk_plane_source_set_normal(vtkPlaneSource* sself, double nx, double ny, double nz) { sself->SetNormal(nx, ny, nz); } +extern "C" void vtk_plane_source_push(vtkPlaneSource* sself, double distance) { sself->Push(distance); } +extern "C" void vtk_plane_source_set_output_points_precision(vtkPlaneSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_plane_source_get_output_points_precision(vtkPlaneSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkPlatonicSolidSource * vtkPlatonicSolidSource_new () {return vtkPlatonicSolidSource :: New () ;} +extern "C" void vtkPlatonicSolidSource_destructor (vtkPlatonicSolidSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_platonic_solid_source_set_solid_type(vtkPlatonicSolidSource* sself, int _arg) { sself->SetSolidType(_arg); } +extern "C" int vtk_platonic_solid_source_get_solid_type_min_value(vtkPlatonicSolidSource* sself) { return sself->GetSolidTypeMinValue(); } +extern "C" int vtk_platonic_solid_source_get_solid_type_max_value(vtkPlatonicSolidSource* sself) { return sself->GetSolidTypeMaxValue(); } +extern "C" int vtk_platonic_solid_source_get_solid_type(vtkPlatonicSolidSource* sself) { return sself->GetSolidType(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_tetrahedron(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToTetrahedron(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_cube(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToCube(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_octahedron(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToOctahedron(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_icosahedron(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToIcosahedron(); } +extern "C" void vtk_platonic_solid_source_set_solid_type_to_dodecahedron(vtkPlatonicSolidSource* sself) { sself->SetSolidTypeToDodecahedron(); } +extern "C" void vtk_platonic_solid_source_set_output_points_precision(vtkPlatonicSolidSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_platonic_solid_source_get_output_points_precision(vtkPlatonicSolidSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkPointHandleSource * vtkPointHandleSource_new () {return vtkPointHandleSource :: New () ;} +extern "C" void vtkPointHandleSource_destructor (vtkPointHandleSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_point_handle_source_set_position(vtkPointHandleSource* sself, double xPos, double yPos, double zPos) { sself->SetPosition(xPos, yPos, zPos); } +extern "C" void vtk_point_handle_source_set_direction(vtkPointHandleSource* sself, double xDir, double yDir, double zDir) { sself->SetDirection(xDir, yDir, zDir); } +extern "C" vtkPointSource * vtkPointSource_new () {return vtkPointSource :: New () ;} +extern "C" void vtkPointSource_destructor (vtkPointSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_point_source_set_number_of_points(vtkPointSource* sself, long long _arg) { sself->SetNumberOfPoints(_arg); } +extern "C" long long vtk_point_source_get_number_of_points_min_value(vtkPointSource* sself) { return sself->GetNumberOfPointsMinValue(); } +extern "C" long long vtk_point_source_get_number_of_points_max_value(vtkPointSource* sself) { return sself->GetNumberOfPointsMaxValue(); } +extern "C" long long vtk_point_source_get_number_of_points(vtkPointSource* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_point_source_set_center(vtkPointSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_point_source_set_radius(vtkPointSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_point_source_get_radius_min_value(vtkPointSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_point_source_get_radius_max_value(vtkPointSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_point_source_get_radius(vtkPointSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_point_source_set_distribution(vtkPointSource* sself, int _arg) { sself->SetDistribution(_arg); } +extern "C" void vtk_point_source_set_distribution_to_uniform(vtkPointSource* sself) { sself->SetDistributionToUniform(); } +extern "C" void vtk_point_source_set_distribution_to_shell(vtkPointSource* sself) { sself->SetDistributionToShell(); } +extern "C" int vtk_point_source_get_distribution(vtkPointSource* sself) { return sself->GetDistribution(); } +extern "C" void vtk_point_source_set_output_points_precision(vtkPointSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_point_source_get_output_points_precision(vtkPointSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkPolyLineSource * vtkPolyLineSource_new () {return vtkPolyLineSource :: New () ;} +extern "C" void vtkPolyLineSource_destructor (vtkPolyLineSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_poly_line_source_set_closed(vtkPolyLineSource* sself, int _arg) { sself->SetClosed(_arg); } +extern "C" int vtk_poly_line_source_get_closed(vtkPolyLineSource* sself) { return sself->GetClosed(); } +extern "C" void vtk_poly_line_source_closed_on(vtkPolyLineSource* sself) { sself->ClosedOn(); } +extern "C" void vtk_poly_line_source_closed_off(vtkPolyLineSource* sself) { sself->ClosedOff(); } +extern "C" vtkPolyPointSource * vtkPolyPointSource_new () {return vtkPolyPointSource :: New () ;} +extern "C" void vtkPolyPointSource_destructor (vtkPolyPointSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_poly_point_source_set_number_of_points(vtkPolyPointSource* sself, long long numPoints) { sself->SetNumberOfPoints(numPoints); } +extern "C" long long vtk_poly_point_source_get_number_of_points(vtkPolyPointSource* sself) { return sself->GetNumberOfPoints(); } +extern "C" void vtk_poly_point_source_resize(vtkPolyPointSource* sself, long long numPoints) { sself->Resize(numPoints); } +extern "C" void vtk_poly_point_source_set_point(vtkPolyPointSource* sself, long long id, double x, double y, double z) { sself->SetPoint(id, x, y, z); } +extern "C" unsigned long vtk_poly_point_source_get_m_time(vtkPolyPointSource* sself) { return sself->GetMTime(); } +extern "C" vtkProgrammableDataObjectSource * vtkProgrammableDataObjectSource_new () {return vtkProgrammableDataObjectSource :: New () ;} +extern "C" void vtkProgrammableDataObjectSource_destructor (vtkProgrammableDataObjectSource * sself) {sself -> Delete () ; return ;} +extern "C" vtkProgrammableSource * vtkProgrammableSource_new () {return vtkProgrammableSource :: New () ;} +extern "C" void vtkProgrammableSource_destructor (vtkProgrammableSource * sself) {sself -> Delete () ; return ;} +extern "C" vtkRandomHyperTreeGridSource * vtkRandomHyperTreeGridSource_new () {return vtkRandomHyperTreeGridSource :: New () ;} +extern "C" void vtkRandomHyperTreeGridSource_destructor (vtkRandomHyperTreeGridSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_random_hyper_tree_grid_source_set_dimensions(vtkRandomHyperTreeGridSource* sself, unsigned int _arg1, unsigned int _arg2, unsigned int _arg3) { sself->SetDimensions(_arg1, _arg2, _arg3); } +extern "C" void vtk_random_hyper_tree_grid_source_set_output_bounds(vtkRandomHyperTreeGridSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) { sself->SetOutputBounds(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" unsigned int vtk_random_hyper_tree_grid_source_get_seed(vtkRandomHyperTreeGridSource* sself) { return sself->GetSeed(); } +extern "C" void vtk_random_hyper_tree_grid_source_set_seed(vtkRandomHyperTreeGridSource* sself, unsigned int _arg) { sself->SetSeed(_arg); } +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth(vtkRandomHyperTreeGridSource* sself) { return sself->GetMaxDepth(); } +extern "C" void vtk_random_hyper_tree_grid_source_set_max_depth(vtkRandomHyperTreeGridSource* sself, long long _arg) { sself->SetMaxDepth(_arg); } +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth_min_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetMaxDepthMinValue(); } +extern "C" long long vtk_random_hyper_tree_grid_source_get_max_depth_max_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetMaxDepthMaxValue(); } +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction(vtkRandomHyperTreeGridSource* sself) { return sself->GetSplitFraction(); } +extern "C" void vtk_random_hyper_tree_grid_source_set_split_fraction(vtkRandomHyperTreeGridSource* sself, double _arg) { sself->SetSplitFraction(_arg); } +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_min_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetSplitFractionMinValue(); } +extern "C" double vtk_random_hyper_tree_grid_source_get_split_fraction_max_value(vtkRandomHyperTreeGridSource* sself) { return sself->GetSplitFractionMaxValue(); } +extern "C" vtkRectangularButtonSource * vtkRectangularButtonSource_new () {return vtkRectangularButtonSource :: New () ;} +extern "C" void vtkRectangularButtonSource_destructor (vtkRectangularButtonSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_rectangular_button_source_set_width(vtkRectangularButtonSource* sself, double _arg) { sself->SetWidth(_arg); } +extern "C" double vtk_rectangular_button_source_get_width_min_value(vtkRectangularButtonSource* sself) { return sself->GetWidthMinValue(); } +extern "C" double vtk_rectangular_button_source_get_width_max_value(vtkRectangularButtonSource* sself) { return sself->GetWidthMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_width(vtkRectangularButtonSource* sself) { return sself->GetWidth(); } +extern "C" void vtk_rectangular_button_source_set_height(vtkRectangularButtonSource* sself, double _arg) { sself->SetHeight(_arg); } +extern "C" double vtk_rectangular_button_source_get_height_min_value(vtkRectangularButtonSource* sself) { return sself->GetHeightMinValue(); } +extern "C" double vtk_rectangular_button_source_get_height_max_value(vtkRectangularButtonSource* sself) { return sself->GetHeightMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_height(vtkRectangularButtonSource* sself) { return sself->GetHeight(); } +extern "C" void vtk_rectangular_button_source_set_depth(vtkRectangularButtonSource* sself, double _arg) { sself->SetDepth(_arg); } +extern "C" double vtk_rectangular_button_source_get_depth_min_value(vtkRectangularButtonSource* sself) { return sself->GetDepthMinValue(); } +extern "C" double vtk_rectangular_button_source_get_depth_max_value(vtkRectangularButtonSource* sself) { return sself->GetDepthMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_depth(vtkRectangularButtonSource* sself) { return sself->GetDepth(); } +extern "C" void vtk_rectangular_button_source_set_box_ratio(vtkRectangularButtonSource* sself, double _arg) { sself->SetBoxRatio(_arg); } +extern "C" double vtk_rectangular_button_source_get_box_ratio_min_value(vtkRectangularButtonSource* sself) { return sself->GetBoxRatioMinValue(); } +extern "C" double vtk_rectangular_button_source_get_box_ratio_max_value(vtkRectangularButtonSource* sself) { return sself->GetBoxRatioMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_box_ratio(vtkRectangularButtonSource* sself) { return sself->GetBoxRatio(); } +extern "C" void vtk_rectangular_button_source_set_texture_ratio(vtkRectangularButtonSource* sself, double _arg) { sself->SetTextureRatio(_arg); } +extern "C" double vtk_rectangular_button_source_get_texture_ratio_min_value(vtkRectangularButtonSource* sself) { return sself->GetTextureRatioMinValue(); } +extern "C" double vtk_rectangular_button_source_get_texture_ratio_max_value(vtkRectangularButtonSource* sself) { return sself->GetTextureRatioMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_texture_ratio(vtkRectangularButtonSource* sself) { return sself->GetTextureRatio(); } +extern "C" void vtk_rectangular_button_source_set_texture_height_ratio(vtkRectangularButtonSource* sself, double _arg) { sself->SetTextureHeightRatio(_arg); } +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio_min_value(vtkRectangularButtonSource* sself) { return sself->GetTextureHeightRatioMinValue(); } +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio_max_value(vtkRectangularButtonSource* sself) { return sself->GetTextureHeightRatioMaxValue(); } +extern "C" double vtk_rectangular_button_source_get_texture_height_ratio(vtkRectangularButtonSource* sself) { return sself->GetTextureHeightRatio(); } +extern "C" void vtk_rectangular_button_source_set_output_points_precision(vtkRectangularButtonSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_rectangular_button_source_get_output_points_precision(vtkRectangularButtonSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkRegularPolygonSource * vtkRegularPolygonSource_new () {return vtkRegularPolygonSource :: New () ;} +extern "C" void vtkRegularPolygonSource_destructor (vtkRegularPolygonSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_regular_polygon_source_set_number_of_sides(vtkRegularPolygonSource* sself, int _arg) { sself->SetNumberOfSides(_arg); } +extern "C" int vtk_regular_polygon_source_get_number_of_sides_min_value(vtkRegularPolygonSource* sself) { return sself->GetNumberOfSidesMinValue(); } +extern "C" int vtk_regular_polygon_source_get_number_of_sides_max_value(vtkRegularPolygonSource* sself) { return sself->GetNumberOfSidesMaxValue(); } +extern "C" int vtk_regular_polygon_source_get_number_of_sides(vtkRegularPolygonSource* sself) { return sself->GetNumberOfSides(); } +extern "C" void vtk_regular_polygon_source_set_center(vtkRegularPolygonSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_regular_polygon_source_set_normal(vtkRegularPolygonSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetNormal(_arg1, _arg2, _arg3); } +extern "C" void vtk_regular_polygon_source_set_radius(vtkRegularPolygonSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_regular_polygon_source_get_radius(vtkRegularPolygonSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_regular_polygon_source_set_generate_polygon(vtkRegularPolygonSource* sself, int _arg) { sself->SetGeneratePolygon(_arg); } +extern "C" int vtk_regular_polygon_source_get_generate_polygon(vtkRegularPolygonSource* sself) { return sself->GetGeneratePolygon(); } +extern "C" void vtk_regular_polygon_source_generate_polygon_on(vtkRegularPolygonSource* sself) { sself->GeneratePolygonOn(); } +extern "C" void vtk_regular_polygon_source_generate_polygon_off(vtkRegularPolygonSource* sself) { sself->GeneratePolygonOff(); } +extern "C" void vtk_regular_polygon_source_set_generate_polyline(vtkRegularPolygonSource* sself, int _arg) { sself->SetGeneratePolyline(_arg); } +extern "C" int vtk_regular_polygon_source_get_generate_polyline(vtkRegularPolygonSource* sself) { return sself->GetGeneratePolyline(); } +extern "C" void vtk_regular_polygon_source_generate_polyline_on(vtkRegularPolygonSource* sself) { sself->GeneratePolylineOn(); } +extern "C" void vtk_regular_polygon_source_generate_polyline_off(vtkRegularPolygonSource* sself) { sself->GeneratePolylineOff(); } +extern "C" void vtk_regular_polygon_source_set_output_points_precision(vtkRegularPolygonSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_regular_polygon_source_get_output_points_precision(vtkRegularPolygonSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkSelectionSource * vtkSelectionSource_new () {return vtkSelectionSource :: New () ;} +extern "C" void vtkSelectionSource_destructor (vtkSelectionSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_selection_source_add_id(vtkSelectionSource* sself, long long piece, long long id) { sself->AddID(piece, id); } +extern "C" void vtk_selection_source_add_string_id(vtkSelectionSource* sself, long long piece, const char* id) { sself->AddStringID(piece, id); } +extern "C" void vtk_selection_source_add_location(vtkSelectionSource* sself, double x, double y, double z) { sself->AddLocation(x, y, z); } +extern "C" void vtk_selection_source_add_threshold(vtkSelectionSource* sself, double min, double max) { sself->AddThreshold(min, max); } +extern "C" void vtk_selection_source_add_block(vtkSelectionSource* sself, long long blockno) { sself->AddBlock(blockno); } +extern "C" void vtk_selection_source_add_block_selector(vtkSelectionSource* sself, const char* selector) { sself->AddBlockSelector(selector); } +extern "C" void vtk_selection_source_remove_all_block_selectors(vtkSelectionSource* sself) { sself->RemoveAllBlockSelectors(); } +extern "C" void vtk_selection_source_remove_all_i_ds(vtkSelectionSource* sself) { sself->RemoveAllIDs(); } +extern "C" void vtk_selection_source_remove_all_string_i_ds(vtkSelectionSource* sself) { sself->RemoveAllStringIDs(); } +extern "C" void vtk_selection_source_remove_all_thresholds(vtkSelectionSource* sself) { sself->RemoveAllThresholds(); } +extern "C" void vtk_selection_source_remove_all_locations(vtkSelectionSource* sself) { sself->RemoveAllLocations(); } +extern "C" void vtk_selection_source_remove_all_blocks(vtkSelectionSource* sself) { sself->RemoveAllBlocks(); } +extern "C" void vtk_selection_source_set_content_type(vtkSelectionSource* sself, int _arg) { sself->SetContentType(_arg); } +extern "C" int vtk_selection_source_get_content_type(vtkSelectionSource* sself) { return sself->GetContentType(); } +extern "C" void vtk_selection_source_set_field_type(vtkSelectionSource* sself, int _arg) { sself->SetFieldType(_arg); } +extern "C" int vtk_selection_source_get_field_type(vtkSelectionSource* sself) { return sself->GetFieldType(); } +extern "C" void vtk_selection_source_set_containing_cells(vtkSelectionSource* sself, int _arg) { sself->SetContainingCells(_arg); } +extern "C" int vtk_selection_source_get_containing_cells(vtkSelectionSource* sself) { return sself->GetContainingCells(); } +extern "C" void vtk_selection_source_set_number_of_layers(vtkSelectionSource* sself, int _arg) { sself->SetNumberOfLayers(_arg); } +extern "C" int vtk_selection_source_get_number_of_layers_min_value(vtkSelectionSource* sself) { return sself->GetNumberOfLayersMinValue(); } +extern "C" int vtk_selection_source_get_number_of_layers_max_value(vtkSelectionSource* sself) { return sself->GetNumberOfLayersMaxValue(); } +extern "C" int vtk_selection_source_get_number_of_layers(vtkSelectionSource* sself) { return sself->GetNumberOfLayers(); } +extern "C" void vtk_selection_source_set_inverse(vtkSelectionSource* sself, int _arg) { sself->SetInverse(_arg); } +extern "C" int vtk_selection_source_get_inverse(vtkSelectionSource* sself) { return sself->GetInverse(); } +extern "C" void vtk_selection_source_set_array_name(vtkSelectionSource* sself, const char* _arg) { sself->SetArrayName(_arg); } +extern "C" void vtk_selection_source_set_array_component(vtkSelectionSource* sself, int _arg) { sself->SetArrayComponent(_arg); } +extern "C" int vtk_selection_source_get_array_component(vtkSelectionSource* sself) { return sself->GetArrayComponent(); } +extern "C" void vtk_selection_source_set_composite_index(vtkSelectionSource* sself, int _arg) { sself->SetCompositeIndex(_arg); } +extern "C" int vtk_selection_source_get_composite_index(vtkSelectionSource* sself) { return sself->GetCompositeIndex(); } +extern "C" void vtk_selection_source_set_hierarchical_level(vtkSelectionSource* sself, int _arg) { sself->SetHierarchicalLevel(_arg); } +extern "C" int vtk_selection_source_get_hierarchical_level(vtkSelectionSource* sself) { return sself->GetHierarchicalLevel(); } +extern "C" void vtk_selection_source_set_hierarchical_index(vtkSelectionSource* sself, int _arg) { sself->SetHierarchicalIndex(_arg); } +extern "C" int vtk_selection_source_get_hierarchical_index(vtkSelectionSource* sself) { return sself->GetHierarchicalIndex(); } +extern "C" void vtk_selection_source_set_assembly_name(vtkSelectionSource* sself, const char* _arg) { sself->SetAssemblyName(_arg); } +extern "C" void vtk_selection_source_add_selector(vtkSelectionSource* sself, const char* selector) { sself->AddSelector(selector); } +extern "C" void vtk_selection_source_remove_all_selectors(vtkSelectionSource* sself) { sself->RemoveAllSelectors(); } +extern "C" void vtk_selection_source_set_query_string(vtkSelectionSource* sself, const char* _arg) { sself->SetQueryString(_arg); } +extern "C" vtkSphereSource * vtkSphereSource_new () {return vtkSphereSource :: New () ;} +extern "C" void vtkSphereSource_destructor (vtkSphereSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_sphere_source_set_radius(vtkSphereSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_sphere_source_get_radius_min_value(vtkSphereSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_sphere_source_get_radius_max_value(vtkSphereSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_sphere_source_get_radius(vtkSphereSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_sphere_source_set_center(vtkSphereSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_sphere_source_set_theta_resolution(vtkSphereSource* sself, int _arg) { sself->SetThetaResolution(_arg); } +extern "C" int vtk_sphere_source_get_theta_resolution_min_value(vtkSphereSource* sself) { return sself->GetThetaResolutionMinValue(); } +extern "C" int vtk_sphere_source_get_theta_resolution_max_value(vtkSphereSource* sself) { return sself->GetThetaResolutionMaxValue(); } +extern "C" int vtk_sphere_source_get_theta_resolution(vtkSphereSource* sself) { return sself->GetThetaResolution(); } +extern "C" void vtk_sphere_source_set_phi_resolution(vtkSphereSource* sself, int _arg) { sself->SetPhiResolution(_arg); } +extern "C" int vtk_sphere_source_get_phi_resolution_min_value(vtkSphereSource* sself) { return sself->GetPhiResolutionMinValue(); } +extern "C" int vtk_sphere_source_get_phi_resolution_max_value(vtkSphereSource* sself) { return sself->GetPhiResolutionMaxValue(); } +extern "C" int vtk_sphere_source_get_phi_resolution(vtkSphereSource* sself) { return sself->GetPhiResolution(); } +extern "C" void vtk_sphere_source_set_start_theta(vtkSphereSource* sself, double _arg) { sself->SetStartTheta(_arg); } +extern "C" double vtk_sphere_source_get_start_theta_min_value(vtkSphereSource* sself) { return sself->GetStartThetaMinValue(); } +extern "C" double vtk_sphere_source_get_start_theta_max_value(vtkSphereSource* sself) { return sself->GetStartThetaMaxValue(); } +extern "C" double vtk_sphere_source_get_start_theta(vtkSphereSource* sself) { return sself->GetStartTheta(); } +extern "C" void vtk_sphere_source_set_end_theta(vtkSphereSource* sself, double _arg) { sself->SetEndTheta(_arg); } +extern "C" double vtk_sphere_source_get_end_theta_min_value(vtkSphereSource* sself) { return sself->GetEndThetaMinValue(); } +extern "C" double vtk_sphere_source_get_end_theta_max_value(vtkSphereSource* sself) { return sself->GetEndThetaMaxValue(); } +extern "C" double vtk_sphere_source_get_end_theta(vtkSphereSource* sself) { return sself->GetEndTheta(); } +extern "C" void vtk_sphere_source_set_start_phi(vtkSphereSource* sself, double _arg) { sself->SetStartPhi(_arg); } +extern "C" double vtk_sphere_source_get_start_phi_min_value(vtkSphereSource* sself) { return sself->GetStartPhiMinValue(); } +extern "C" double vtk_sphere_source_get_start_phi_max_value(vtkSphereSource* sself) { return sself->GetStartPhiMaxValue(); } +extern "C" double vtk_sphere_source_get_start_phi(vtkSphereSource* sself) { return sself->GetStartPhi(); } +extern "C" void vtk_sphere_source_set_end_phi(vtkSphereSource* sself, double _arg) { sself->SetEndPhi(_arg); } +extern "C" double vtk_sphere_source_get_end_phi_min_value(vtkSphereSource* sself) { return sself->GetEndPhiMinValue(); } +extern "C" double vtk_sphere_source_get_end_phi_max_value(vtkSphereSource* sself) { return sself->GetEndPhiMaxValue(); } +extern "C" double vtk_sphere_source_get_end_phi(vtkSphereSource* sself) { return sself->GetEndPhi(); } +extern "C" void vtk_sphere_source_set_lat_long_tessellation(vtkSphereSource* sself, int _arg) { sself->SetLatLongTessellation(_arg); } +extern "C" int vtk_sphere_source_get_lat_long_tessellation(vtkSphereSource* sself) { return sself->GetLatLongTessellation(); } +extern "C" void vtk_sphere_source_lat_long_tessellation_on(vtkSphereSource* sself) { sself->LatLongTessellationOn(); } +extern "C" void vtk_sphere_source_lat_long_tessellation_off(vtkSphereSource* sself) { sself->LatLongTessellationOff(); } +extern "C" void vtk_sphere_source_set_output_points_precision(vtkSphereSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_sphere_source_get_output_points_precision(vtkSphereSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" void vtk_sphere_source_set_generate_normals(vtkSphereSource* sself, int _arg) { sself->SetGenerateNormals(_arg); } +extern "C" int vtk_sphere_source_get_generate_normals(vtkSphereSource* sself) { return sself->GetGenerateNormals(); } +extern "C" void vtk_sphere_source_generate_normals_on(vtkSphereSource* sself) { sself->GenerateNormalsOn(); } +extern "C" void vtk_sphere_source_generate_normals_off(vtkSphereSource* sself) { sself->GenerateNormalsOff(); } +extern "C" vtkSuperquadricSource * vtkSuperquadricSource_new () {return vtkSuperquadricSource :: New () ;} +extern "C" void vtkSuperquadricSource_destructor (vtkSuperquadricSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_superquadric_source_set_center(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetCenter(_arg1, _arg2, _arg3); } +extern "C" void vtk_superquadric_source_set_scale(vtkSuperquadricSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetScale(_arg1, _arg2, _arg3); } +extern "C" int vtk_superquadric_source_get_theta_resolution(vtkSuperquadricSource* sself) { return sself->GetThetaResolution(); } +extern "C" void vtk_superquadric_source_set_theta_resolution(vtkSuperquadricSource* sself, int i) { sself->SetThetaResolution(i); } +extern "C" int vtk_superquadric_source_get_phi_resolution(vtkSuperquadricSource* sself) { return sself->GetPhiResolution(); } +extern "C" void vtk_superquadric_source_set_phi_resolution(vtkSuperquadricSource* sself, int i) { sself->SetPhiResolution(i); } +extern "C" double vtk_superquadric_source_get_thickness(vtkSuperquadricSource* sself) { return sself->GetThickness(); } +extern "C" void vtk_superquadric_source_set_thickness(vtkSuperquadricSource* sself, double _arg) { sself->SetThickness(_arg); } +extern "C" double vtk_superquadric_source_get_thickness_min_value(vtkSuperquadricSource* sself) { return sself->GetThicknessMinValue(); } +extern "C" double vtk_superquadric_source_get_thickness_max_value(vtkSuperquadricSource* sself) { return sself->GetThicknessMaxValue(); } +extern "C" double vtk_superquadric_source_get_phi_roundness(vtkSuperquadricSource* sself) { return sself->GetPhiRoundness(); } +extern "C" void vtk_superquadric_source_set_phi_roundness(vtkSuperquadricSource* sself, double e) { sself->SetPhiRoundness(e); } +extern "C" double vtk_superquadric_source_get_theta_roundness(vtkSuperquadricSource* sself) { return sself->GetThetaRoundness(); } +extern "C" void vtk_superquadric_source_set_theta_roundness(vtkSuperquadricSource* sself, double e) { sself->SetThetaRoundness(e); } +extern "C" void vtk_superquadric_source_set_size(vtkSuperquadricSource* sself, double _arg) { sself->SetSize(_arg); } +extern "C" double vtk_superquadric_source_get_size(vtkSuperquadricSource* sself) { return sself->GetSize(); } +extern "C" void vtk_superquadric_source_set_axis_of_symmetry(vtkSuperquadricSource* sself, int _arg) { sself->SetAxisOfSymmetry(_arg); } +extern "C" int vtk_superquadric_source_get_axis_of_symmetry(vtkSuperquadricSource* sself) { return sself->GetAxisOfSymmetry(); } +extern "C" void vtk_superquadric_source_set_x_axis_of_symmetry(vtkSuperquadricSource* sself) { sself->SetXAxisOfSymmetry(); } +extern "C" void vtk_superquadric_source_set_y_axis_of_symmetry(vtkSuperquadricSource* sself) { sself->SetYAxisOfSymmetry(); } +extern "C" void vtk_superquadric_source_set_z_axis_of_symmetry(vtkSuperquadricSource* sself) { sself->SetZAxisOfSymmetry(); } +extern "C" void vtk_superquadric_source_toroidal_on(vtkSuperquadricSource* sself) { sself->ToroidalOn(); } +extern "C" void vtk_superquadric_source_toroidal_off(vtkSuperquadricSource* sself) { sself->ToroidalOff(); } +extern "C" int vtk_superquadric_source_get_toroidal(vtkSuperquadricSource* sself) { return sself->GetToroidal(); } +extern "C" void vtk_superquadric_source_set_toroidal(vtkSuperquadricSource* sself, int _arg) { sself->SetToroidal(_arg); } +extern "C" void vtk_superquadric_source_set_output_points_precision(vtkSuperquadricSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_superquadric_source_get_output_points_precision(vtkSuperquadricSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkTessellatedBoxSource * vtkTessellatedBoxSource_new () {return vtkTessellatedBoxSource :: New () ;} +extern "C" void vtkTessellatedBoxSource_destructor (vtkTessellatedBoxSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_tessellated_box_source_set_bounds(vtkTessellatedBoxSource* sself, double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) { sself->SetBounds(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6); } +extern "C" void vtk_tessellated_box_source_set_level(vtkTessellatedBoxSource* sself, int _arg) { sself->SetLevel(_arg); } +extern "C" int vtk_tessellated_box_source_get_level(vtkTessellatedBoxSource* sself) { return sself->GetLevel(); } +extern "C" void vtk_tessellated_box_source_set_duplicate_shared_points(vtkTessellatedBoxSource* sself, int _arg) { sself->SetDuplicateSharedPoints(_arg); } +extern "C" int vtk_tessellated_box_source_get_duplicate_shared_points(vtkTessellatedBoxSource* sself) { return sself->GetDuplicateSharedPoints(); } +extern "C" void vtk_tessellated_box_source_duplicate_shared_points_on(vtkTessellatedBoxSource* sself) { sself->DuplicateSharedPointsOn(); } +extern "C" void vtk_tessellated_box_source_duplicate_shared_points_off(vtkTessellatedBoxSource* sself) { sself->DuplicateSharedPointsOff(); } +extern "C" void vtk_tessellated_box_source_set_quads(vtkTessellatedBoxSource* sself, int _arg) { sself->SetQuads(_arg); } +extern "C" int vtk_tessellated_box_source_get_quads(vtkTessellatedBoxSource* sself) { return sself->GetQuads(); } +extern "C" void vtk_tessellated_box_source_quads_on(vtkTessellatedBoxSource* sself) { sself->QuadsOn(); } +extern "C" void vtk_tessellated_box_source_quads_off(vtkTessellatedBoxSource* sself) { sself->QuadsOff(); } +extern "C" void vtk_tessellated_box_source_set_output_points_precision(vtkTessellatedBoxSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_tessellated_box_source_get_output_points_precision(vtkTessellatedBoxSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkTextSource * vtkTextSource_new () {return vtkTextSource :: New () ;} +extern "C" void vtkTextSource_destructor (vtkTextSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_text_source_set_text(vtkTextSource* sself, const char* _arg) { sself->SetText(_arg); } +extern "C" void vtk_text_source_set_backing(vtkTextSource* sself, int _arg) { sself->SetBacking(_arg); } +extern "C" int vtk_text_source_get_backing(vtkTextSource* sself) { return sself->GetBacking(); } +extern "C" void vtk_text_source_backing_on(vtkTextSource* sself) { sself->BackingOn(); } +extern "C" void vtk_text_source_backing_off(vtkTextSource* sself) { sself->BackingOff(); } +extern "C" void vtk_text_source_set_foreground_color(vtkTextSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetForegroundColor(_arg1, _arg2, _arg3); } +extern "C" void vtk_text_source_set_background_color(vtkTextSource* sself, double _arg1, double _arg2, double _arg3) { sself->SetBackgroundColor(_arg1, _arg2, _arg3); } +extern "C" void vtk_text_source_set_output_points_precision(vtkTextSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_text_source_get_output_points_precision(vtkTextSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkTexturedSphereSource * vtkTexturedSphereSource_new () {return vtkTexturedSphereSource :: New () ;} +extern "C" void vtkTexturedSphereSource_destructor (vtkTexturedSphereSource * sself) {sself -> Delete () ; return ;} +extern "C" void vtk_textured_sphere_source_set_radius(vtkTexturedSphereSource* sself, double _arg) { sself->SetRadius(_arg); } +extern "C" double vtk_textured_sphere_source_get_radius_min_value(vtkTexturedSphereSource* sself) { return sself->GetRadiusMinValue(); } +extern "C" double vtk_textured_sphere_source_get_radius_max_value(vtkTexturedSphereSource* sself) { return sself->GetRadiusMaxValue(); } +extern "C" double vtk_textured_sphere_source_get_radius(vtkTexturedSphereSource* sself) { return sself->GetRadius(); } +extern "C" void vtk_textured_sphere_source_set_theta_resolution(vtkTexturedSphereSource* sself, int _arg) { sself->SetThetaResolution(_arg); } +extern "C" int vtk_textured_sphere_source_get_theta_resolution_min_value(vtkTexturedSphereSource* sself) { return sself->GetThetaResolutionMinValue(); } +extern "C" int vtk_textured_sphere_source_get_theta_resolution_max_value(vtkTexturedSphereSource* sself) { return sself->GetThetaResolutionMaxValue(); } +extern "C" int vtk_textured_sphere_source_get_theta_resolution(vtkTexturedSphereSource* sself) { return sself->GetThetaResolution(); } +extern "C" void vtk_textured_sphere_source_set_phi_resolution(vtkTexturedSphereSource* sself, int _arg) { sself->SetPhiResolution(_arg); } +extern "C" int vtk_textured_sphere_source_get_phi_resolution_min_value(vtkTexturedSphereSource* sself) { return sself->GetPhiResolutionMinValue(); } +extern "C" int vtk_textured_sphere_source_get_phi_resolution_max_value(vtkTexturedSphereSource* sself) { return sself->GetPhiResolutionMaxValue(); } +extern "C" int vtk_textured_sphere_source_get_phi_resolution(vtkTexturedSphereSource* sself) { return sself->GetPhiResolution(); } +extern "C" void vtk_textured_sphere_source_set_theta(vtkTexturedSphereSource* sself, double _arg) { sself->SetTheta(_arg); } +extern "C" double vtk_textured_sphere_source_get_theta_min_value(vtkTexturedSphereSource* sself) { return sself->GetThetaMinValue(); } +extern "C" double vtk_textured_sphere_source_get_theta_max_value(vtkTexturedSphereSource* sself) { return sself->GetThetaMaxValue(); } +extern "C" double vtk_textured_sphere_source_get_theta(vtkTexturedSphereSource* sself) { return sself->GetTheta(); } +extern "C" void vtk_textured_sphere_source_set_phi(vtkTexturedSphereSource* sself, double _arg) { sself->SetPhi(_arg); } +extern "C" double vtk_textured_sphere_source_get_phi_min_value(vtkTexturedSphereSource* sself) { return sself->GetPhiMinValue(); } +extern "C" double vtk_textured_sphere_source_get_phi_max_value(vtkTexturedSphereSource* sself) { return sself->GetPhiMaxValue(); } +extern "C" double vtk_textured_sphere_source_get_phi(vtkTexturedSphereSource* sself) { return sself->GetPhi(); } +extern "C" void vtk_textured_sphere_source_set_output_points_precision(vtkTexturedSphereSource* sself, int _arg) { sself->SetOutputPointsPrecision(_arg); } +extern "C" int vtk_textured_sphere_source_get_output_points_precision(vtkTexturedSphereSource* sself) { return sself->GetOutputPointsPrecision(); } +extern "C" vtkUniformHyperTreeGridSource * vtkUniformHyperTreeGridSource_new () {return vtkUniformHyperTreeGridSource :: New () ;} +extern "C" void vtkUniformHyperTreeGridSource_destructor (vtkUniformHyperTreeGridSource * sself) {sself -> Delete () ; return ;} diff --git a/vtk-rs-9.1/src/lib.rs b/vtk-rs-9.1/src/lib.rs index f5d6964..536b51e 100644 --- a/vtk-rs-9.1/src/lib.rs +++ b/vtk-rs-9.1/src/lib.rs @@ -1,6 +1,5 @@ #![allow(non_camel_case_types)] #![allow(non_snake_case)] -pub mod vtkCommonArchive; pub mod vtkCommonColor; pub mod vtkCommonComputationalGeometry; pub mod vtkCommonCore; @@ -8,6 +7,431 @@ pub mod vtkCommonDataModel; pub mod vtkCommonExecutionModel; pub mod vtkCommonMath; pub mod vtkCommonMisc; -pub mod vtkCommonPython; pub mod vtkCommonSystem; pub mod vtkCommonTransforms; +pub mod vtkFiltersSources; +pub use vtkCommonColor::vtkColorSeries as ColorSeries; +pub use vtkCommonColor::vtkNamedColors as NamedColors; +pub use vtkCommonComputationalGeometry::vtkCardinalSpline as CardinalSpline; +pub use vtkCommonComputationalGeometry::vtkKochanekSpline as KochanekSpline; +pub use vtkCommonComputationalGeometry::vtkParametricBohemianDome as ParametricBohemianDome; +pub use vtkCommonComputationalGeometry::vtkParametricBour as ParametricBour; +pub use vtkCommonComputationalGeometry::vtkParametricBoy as ParametricBoy; +pub use vtkCommonComputationalGeometry::vtkParametricCatalanMinimal as ParametricCatalanMinimal; +pub use vtkCommonComputationalGeometry::vtkParametricConicSpiral as ParametricConicSpiral; +pub use vtkCommonComputationalGeometry::vtkParametricCrossCap as ParametricCrossCap; +pub use vtkCommonComputationalGeometry::vtkParametricDini as ParametricDini; +pub use vtkCommonComputationalGeometry::vtkParametricEllipsoid as ParametricEllipsoid; +pub use vtkCommonComputationalGeometry::vtkParametricEnneper as ParametricEnneper; +pub use vtkCommonComputationalGeometry::vtkParametricFigure8Klein as ParametricFigure8Klein; +pub use vtkCommonComputationalGeometry::vtkParametricHenneberg as ParametricHenneberg; +pub use vtkCommonComputationalGeometry::vtkParametricKlein as ParametricKlein; +pub use vtkCommonComputationalGeometry::vtkParametricKuen as ParametricKuen; +pub use vtkCommonComputationalGeometry::vtkParametricMobius as ParametricMobius; +pub use vtkCommonComputationalGeometry::vtkParametricPluckerConoid as ParametricPluckerConoid; +pub use vtkCommonComputationalGeometry::vtkParametricPseudosphere as ParametricPseudosphere; +pub use vtkCommonComputationalGeometry::vtkParametricRandomHills as ParametricRandomHills; +pub use vtkCommonComputationalGeometry::vtkParametricRoman as ParametricRoman; +pub use vtkCommonComputationalGeometry::vtkParametricSpline as ParametricSpline; +pub use vtkCommonComputationalGeometry::vtkParametricSuperEllipsoid as ParametricSuperEllipsoid; +pub use vtkCommonComputationalGeometry::vtkParametricSuperToroid as ParametricSuperToroid; +pub use vtkCommonComputationalGeometry::vtkParametricTorus as ParametricTorus; +pub use vtkCommonCore::vtkAnimationCue as AnimationCue; +pub use vtkCommonCore::vtkArchiver as Archiver; +pub use vtkCommonCore::vtkBitArray as BitArray; +pub use vtkCommonCore::vtkBitArrayIterator as BitArrayIterator; +pub use vtkCommonCore::vtkBoxMuellerRandomSequence as BoxMuellerRandomSequence; +pub use vtkCommonCore::vtkByteSwap as ByteSwap; +pub use vtkCommonCore::vtkCallbackCommand as CallbackCommand; +pub use vtkCommonCore::vtkCharArray as CharArray; +pub use vtkCommonCore::vtkCollection as Collection; +pub use vtkCommonCore::vtkCollectionIterator as CollectionIterator; +pub use vtkCommonCore::vtkCriticalSection as CriticalSection; +pub use vtkCommonCore::vtkDataArrayCollection as DataArrayCollection; +pub use vtkCommonCore::vtkDataArrayCollectionIterator as DataArrayCollectionIterator; +pub use vtkCommonCore::vtkDataArraySelection as DataArraySelection; +pub use vtkCommonCore::vtkDebugLeaks as DebugLeaks; +pub use vtkCommonCore::vtkDoubleArray as DoubleArray; +pub use vtkCommonCore::vtkDynamicLoader as DynamicLoader; +pub use vtkCommonCore::vtkEventDataDevice3D as EventDataDevice3D; +pub use vtkCommonCore::vtkEventDataForDevice as EventDataForDevice; +pub use vtkCommonCore::vtkEventForwarderCommand as EventForwarderCommand; +pub use vtkCommonCore::vtkFileOutputWindow as FileOutputWindow; +pub use vtkCommonCore::vtkFloatArray as FloatArray; +pub use vtkCommonCore::vtkGarbageCollector as GarbageCollector; +pub use vtkCommonCore::vtkIdList as IdList; +pub use vtkCommonCore::vtkIdListCollection as IdListCollection; +pub use vtkCommonCore::vtkIdTypeArray as IdTypeArray; +pub use vtkCommonCore::vtkInformation as Information; +pub use vtkCommonCore::vtkInformationIterator as InformationIterator; +pub use vtkCommonCore::vtkInformationKeyLookup as InformationKeyLookup; +pub use vtkCommonCore::vtkInformationVector as InformationVector; +pub use vtkCommonCore::vtkIntArray as IntArray; +pub use vtkCommonCore::vtkLongArray as LongArray; +pub use vtkCommonCore::vtkLongLongArray as LongLongArray; +pub use vtkCommonCore::vtkLookupTable as LookupTable; +pub use vtkCommonCore::vtkMath as Math; +pub use vtkCommonCore::vtkMersenneTwister as MersenneTwister; +pub use vtkCommonCore::vtkMinimalStandardRandomSequence as MinimalStandardRandomSequence; +pub use vtkCommonCore::vtkMultiThreader as MultiThreader; +pub use vtkCommonCore::vtkObject as Object; +pub use vtkCommonCore::vtkObjectFactoryCollection as ObjectFactoryCollection; +pub use vtkCommonCore::vtkOldStyleCallbackCommand as OldStyleCallbackCommand; +pub use vtkCommonCore::vtkOutputWindow as OutputWindow; +pub use vtkCommonCore::vtkOverrideInformationCollection as OverrideInformationCollection; +pub use vtkCommonCore::vtkPoints as Points; +pub use vtkCommonCore::vtkPoints2D as Points2D; +pub use vtkCommonCore::vtkPriorityQueue as PriorityQueue; +pub use vtkCommonCore::vtkRandomPool as RandomPool; +pub use vtkCommonCore::vtkReferenceCount as ReferenceCount; +pub use vtkCommonCore::vtkScalarsToColors as ScalarsToColors; +pub use vtkCommonCore::vtkShortArray as ShortArray; +pub use vtkCommonCore::vtkSignedCharArray as SignedCharArray; +pub use vtkCommonCore::vtkSortDataArray as SortDataArray; +pub use vtkCommonCore::vtkStringArray as StringArray; +pub use vtkCommonCore::vtkStringOutputWindow as StringOutputWindow; +pub use vtkCommonCore::vtkTimePointUtility as TimePointUtility; +pub use vtkCommonCore::vtkTypeFloat32Array as TypeFloat32Array; +pub use vtkCommonCore::vtkTypeFloat64Array as TypeFloat64Array; +pub use vtkCommonCore::vtkTypeInt16Array as TypeInt16Array; +pub use vtkCommonCore::vtkTypeInt32Array as TypeInt32Array; +pub use vtkCommonCore::vtkTypeInt64Array as TypeInt64Array; +pub use vtkCommonCore::vtkTypeInt8Array as TypeInt8Array; +pub use vtkCommonCore::vtkTypeUInt16Array as TypeUInt16Array; +pub use vtkCommonCore::vtkTypeUInt32Array as TypeUInt32Array; +pub use vtkCommonCore::vtkTypeUInt64Array as TypeUInt64Array; +pub use vtkCommonCore::vtkTypeUInt8Array as TypeUInt8Array; +pub use vtkCommonCore::vtkUnicodeStringArray as UnicodeStringArray; +pub use vtkCommonCore::vtkUnsignedCharArray as UnsignedCharArray; +pub use vtkCommonCore::vtkUnsignedIntArray as UnsignedIntArray; +pub use vtkCommonCore::vtkUnsignedLongArray as UnsignedLongArray; +pub use vtkCommonCore::vtkUnsignedLongLongArray as UnsignedLongLongArray; +pub use vtkCommonCore::vtkUnsignedShortArray as UnsignedShortArray; +pub use vtkCommonCore::vtkVariantArray as VariantArray; +pub use vtkCommonCore::vtkVersion as Version; +pub use vtkCommonCore::vtkVoidArray as VoidArray; +pub use vtkCommonCore::vtkWeakReference as WeakReference; +pub use vtkCommonCore::vtkXMLFileOutputWindow as XMLFileOutputWindow; +pub use vtkCommonDataModel::vtkAMRDataInternals as AMRDataInternals; +pub use vtkCommonDataModel::vtkAdjacentVertexIterator as AdjacentVertexIterator; +pub use vtkCommonDataModel::vtkAnimationScene as AnimationScene; +pub use vtkCommonDataModel::vtkAnnotation as Annotation; +pub use vtkCommonDataModel::vtkAnnotationLayers as AnnotationLayers; +pub use vtkCommonDataModel::vtkArrayData as ArrayData; +pub use vtkCommonDataModel::vtkAttributesErrorMetric as AttributesErrorMetric; +pub use vtkCommonDataModel::vtkBSPCuts as BSPCuts; +pub use vtkCommonDataModel::vtkBSPIntersections as BSPIntersections; +pub use vtkCommonDataModel::vtkBezierCurve as BezierCurve; +pub use vtkCommonDataModel::vtkBezierHexahedron as BezierHexahedron; +pub use vtkCommonDataModel::vtkBezierInterpolation as BezierInterpolation; +pub use vtkCommonDataModel::vtkBezierQuadrilateral as BezierQuadrilateral; +pub use vtkCommonDataModel::vtkBezierTetra as BezierTetra; +pub use vtkCommonDataModel::vtkBezierTriangle as BezierTriangle; +pub use vtkCommonDataModel::vtkBezierWedge as BezierWedge; +pub use vtkCommonDataModel::vtkBiQuadraticQuad as BiQuadraticQuad; +pub use vtkCommonDataModel::vtkBiQuadraticQuadraticHexahedron as BiQuadraticQuadraticHexahedron; +pub use vtkCommonDataModel::vtkBiQuadraticQuadraticWedge as BiQuadraticQuadraticWedge; +pub use vtkCommonDataModel::vtkBiQuadraticTriangle as BiQuadraticTriangle; +pub use vtkCommonDataModel::vtkBox as Box; +pub use vtkCommonDataModel::vtkCellArray as CellArray; +pub use vtkCommonDataModel::vtkCellArrayIterator as CellArrayIterator; +pub use vtkCommonDataModel::vtkCellData as CellData; +pub use vtkCommonDataModel::vtkCellLinks as CellLinks; +pub use vtkCommonDataModel::vtkCellLocator as CellLocator; +pub use vtkCommonDataModel::vtkCellLocatorStrategy as CellLocatorStrategy; +pub use vtkCommonDataModel::vtkCellTypes as CellTypes; +pub use vtkCommonDataModel::vtkClosestNPointsStrategy as ClosestNPointsStrategy; +pub use vtkCommonDataModel::vtkClosestPointStrategy as ClosestPointStrategy; +pub use vtkCommonDataModel::vtkCone as Cone; +pub use vtkCommonDataModel::vtkConvexPointSet as ConvexPointSet; +pub use vtkCommonDataModel::vtkCubicLine as CubicLine; +pub use vtkCommonDataModel::vtkCylinder as Cylinder; +pub use vtkCommonDataModel::vtkDataAssembly as DataAssembly; +pub use vtkCommonDataModel::vtkDataAssemblyUtilities as DataAssemblyUtilities; +pub use vtkCommonDataModel::vtkDataObject as DataObject; +pub use vtkCommonDataModel::vtkDataObjectCollection as DataObjectCollection; +pub use vtkCommonDataModel::vtkDataObjectTreeIterator as DataObjectTreeIterator; +pub use vtkCommonDataModel::vtkDataObjectTypes as DataObjectTypes; +pub use vtkCommonDataModel::vtkDataSetAttributes as DataSetAttributes; +pub use vtkCommonDataModel::vtkDataSetCellIterator as DataSetCellIterator; +pub use vtkCommonDataModel::vtkDataSetCollection as DataSetCollection; +pub use vtkCommonDataModel::vtkDirectedAcyclicGraph as DirectedAcyclicGraph; +pub use vtkCommonDataModel::vtkDirectedGraph as DirectedGraph; +pub use vtkCommonDataModel::vtkEdgeListIterator as EdgeListIterator; +pub use vtkCommonDataModel::vtkEdgeTable as EdgeTable; +pub use vtkCommonDataModel::vtkEmptyCell as EmptyCell; +pub use vtkCommonDataModel::vtkExplicitStructuredGrid as ExplicitStructuredGrid; +pub use vtkCommonDataModel::vtkExtractStructuredGridHelper as ExtractStructuredGridHelper; +pub use vtkCommonDataModel::vtkFieldData as FieldData; +pub use vtkCommonDataModel::vtkGenericAttributeCollection as GenericAttributeCollection; +pub use vtkCommonDataModel::vtkGenericCell as GenericCell; +pub use vtkCommonDataModel::vtkGenericEdgeTable as GenericEdgeTable; +pub use vtkCommonDataModel::vtkGenericInterpolatedVelocityField as GenericInterpolatedVelocityField; +pub use vtkCommonDataModel::vtkGeometricErrorMetric as GeometricErrorMetric; +pub use vtkCommonDataModel::vtkGraphEdge as GraphEdge; +pub use vtkCommonDataModel::vtkGraphInternals as GraphInternals; +pub use vtkCommonDataModel::vtkHexagonalPrism as HexagonalPrism; +pub use vtkCommonDataModel::vtkHexahedron as Hexahedron; +pub use vtkCommonDataModel::vtkHierarchicalBoxDataIterator as HierarchicalBoxDataIterator; +pub use vtkCommonDataModel::vtkHierarchicalBoxDataSet as HierarchicalBoxDataSet; +pub use vtkCommonDataModel::vtkHyperTreeGrid as HyperTreeGrid; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedCursor as HyperTreeGridNonOrientedCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedGeometryCursor as HyperTreeGridNonOrientedGeometryCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedMooreSuperCursor as HyperTreeGridNonOrientedMooreSuperCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedMooreSuperCursorLight as HyperTreeGridNonOrientedMooreSuperCursorLight; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedVonNeumannSuperCursor as HyperTreeGridNonOrientedVonNeumannSuperCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight as HyperTreeGridNonOrientedVonNeumannSuperCursorLight; +pub use vtkCommonDataModel::vtkHyperTreeGridOrientedCursor as HyperTreeGridOrientedCursor; +pub use vtkCommonDataModel::vtkHyperTreeGridOrientedGeometryCursor as HyperTreeGridOrientedGeometryCursor; +pub use vtkCommonDataModel::vtkImageData as ImageData; +pub use vtkCommonDataModel::vtkImageTransform as ImageTransform; +pub use vtkCommonDataModel::vtkImplicitBoolean as ImplicitBoolean; +pub use vtkCommonDataModel::vtkImplicitDataSet as ImplicitDataSet; +pub use vtkCommonDataModel::vtkImplicitFunctionCollection as ImplicitFunctionCollection; +pub use vtkCommonDataModel::vtkImplicitHalo as ImplicitHalo; +pub use vtkCommonDataModel::vtkImplicitSelectionLoop as ImplicitSelectionLoop; +pub use vtkCommonDataModel::vtkImplicitSum as ImplicitSum; +pub use vtkCommonDataModel::vtkImplicitVolume as ImplicitVolume; +pub use vtkCommonDataModel::vtkImplicitWindowFunction as ImplicitWindowFunction; +pub use vtkCommonDataModel::vtkInEdgeIterator as InEdgeIterator; +pub use vtkCommonDataModel::vtkIncrementalOctreeNode as IncrementalOctreeNode; +pub use vtkCommonDataModel::vtkIncrementalOctreePointLocator as IncrementalOctreePointLocator; +pub use vtkCommonDataModel::vtkIterativeClosestPointTransform as IterativeClosestPointTransform; +pub use vtkCommonDataModel::vtkKdNode as KdNode; +pub use vtkCommonDataModel::vtkKdTree as KdTree; +pub use vtkCommonDataModel::vtkKdTreePointLocator as KdTreePointLocator; +pub use vtkCommonDataModel::vtkLagrangeCurve as LagrangeCurve; +pub use vtkCommonDataModel::vtkLagrangeHexahedron as LagrangeHexahedron; +pub use vtkCommonDataModel::vtkLagrangeInterpolation as LagrangeInterpolation; +pub use vtkCommonDataModel::vtkLagrangeQuadrilateral as LagrangeQuadrilateral; +pub use vtkCommonDataModel::vtkLagrangeTetra as LagrangeTetra; +pub use vtkCommonDataModel::vtkLagrangeTriangle as LagrangeTriangle; +pub use vtkCommonDataModel::vtkLagrangeWedge as LagrangeWedge; +pub use vtkCommonDataModel::vtkLine as Line; +pub use vtkCommonDataModel::vtkMeanValueCoordinatesInterpolator as MeanValueCoordinatesInterpolator; +pub use vtkCommonDataModel::vtkMergePoints as MergePoints; +pub use vtkCommonDataModel::vtkMolecule as Molecule; +pub use vtkCommonDataModel::vtkMultiBlockDataSet as MultiBlockDataSet; +pub use vtkCommonDataModel::vtkMultiPieceDataSet as MultiPieceDataSet; +pub use vtkCommonDataModel::vtkMutableDirectedGraph as MutableDirectedGraph; +pub use vtkCommonDataModel::vtkMutableUndirectedGraph as MutableUndirectedGraph; +pub use vtkCommonDataModel::vtkNonMergingPointLocator as NonMergingPointLocator; +pub use vtkCommonDataModel::vtkNonOverlappingAMR as NonOverlappingAMR; +pub use vtkCommonDataModel::vtkOctreePointLocator as OctreePointLocator; +pub use vtkCommonDataModel::vtkOctreePointLocatorNode as OctreePointLocatorNode; +pub use vtkCommonDataModel::vtkOrderedTriangulator as OrderedTriangulator; +pub use vtkCommonDataModel::vtkOutEdgeIterator as OutEdgeIterator; +pub use vtkCommonDataModel::vtkOverlappingAMR as OverlappingAMR; +pub use vtkCommonDataModel::vtkPartitionedDataSet as PartitionedDataSet; +pub use vtkCommonDataModel::vtkPartitionedDataSetCollection as PartitionedDataSetCollection; +pub use vtkCommonDataModel::vtkPath as Path; +pub use vtkCommonDataModel::vtkPentagonalPrism as PentagonalPrism; +pub use vtkCommonDataModel::vtkPerlinNoise as PerlinNoise; +pub use vtkCommonDataModel::vtkPiecewiseFunction as PiecewiseFunction; +pub use vtkCommonDataModel::vtkPixel as Pixel; +pub use vtkCommonDataModel::vtkPlane as Plane; +pub use vtkCommonDataModel::vtkPlaneCollection as PlaneCollection; +pub use vtkCommonDataModel::vtkPlanes as Planes; +pub use vtkCommonDataModel::vtkPlanesIntersection as PlanesIntersection; +pub use vtkCommonDataModel::vtkPointData as PointData; +pub use vtkCommonDataModel::vtkPointLocator as PointLocator; +pub use vtkCommonDataModel::vtkPointSet as PointSet; +pub use vtkCommonDataModel::vtkPointSetCellIterator as PointSetCellIterator; +pub use vtkCommonDataModel::vtkPointsProjectedHull as PointsProjectedHull; +pub use vtkCommonDataModel::vtkPolyData as PolyData; +pub use vtkCommonDataModel::vtkPolyDataCollection as PolyDataCollection; +pub use vtkCommonDataModel::vtkPolyLine as PolyLine; +pub use vtkCommonDataModel::vtkPolyPlane as PolyPlane; +pub use vtkCommonDataModel::vtkPolyVertex as PolyVertex; +pub use vtkCommonDataModel::vtkPolygon as Polygon; +pub use vtkCommonDataModel::vtkPolyhedron as Polyhedron; +pub use vtkCommonDataModel::vtkPyramid as Pyramid; +pub use vtkCommonDataModel::vtkQuad as Quad; +pub use vtkCommonDataModel::vtkQuadraticEdge as QuadraticEdge; +pub use vtkCommonDataModel::vtkQuadraticHexahedron as QuadraticHexahedron; +pub use vtkCommonDataModel::vtkQuadraticLinearQuad as QuadraticLinearQuad; +pub use vtkCommonDataModel::vtkQuadraticLinearWedge as QuadraticLinearWedge; +pub use vtkCommonDataModel::vtkQuadraticPolygon as QuadraticPolygon; +pub use vtkCommonDataModel::vtkQuadraticPyramid as QuadraticPyramid; +pub use vtkCommonDataModel::vtkQuadraticQuad as QuadraticQuad; +pub use vtkCommonDataModel::vtkQuadraticTetra as QuadraticTetra; +pub use vtkCommonDataModel::vtkQuadraticTriangle as QuadraticTriangle; +pub use vtkCommonDataModel::vtkQuadraticWedge as QuadraticWedge; +pub use vtkCommonDataModel::vtkQuadratureSchemeDefinition as QuadratureSchemeDefinition; +pub use vtkCommonDataModel::vtkQuadric as Quadric; +pub use vtkCommonDataModel::vtkRectilinearGrid as RectilinearGrid; +pub use vtkCommonDataModel::vtkReebGraph as ReebGraph; +pub use vtkCommonDataModel::vtkReebGraphSimplificationMetric as ReebGraphSimplificationMetric; +pub use vtkCommonDataModel::vtkSelection as Selection; +pub use vtkCommonDataModel::vtkSelectionNode as SelectionNode; +pub use vtkCommonDataModel::vtkSimpleCellTessellator as SimpleCellTessellator; +pub use vtkCommonDataModel::vtkSmoothErrorMetric as SmoothErrorMetric; +pub use vtkCommonDataModel::vtkSortFieldData as SortFieldData; +pub use vtkCommonDataModel::vtkSphere as Sphere; +pub use vtkCommonDataModel::vtkSpheres as Spheres; +pub use vtkCommonDataModel::vtkStaticCellLinks as StaticCellLinks; +pub use vtkCommonDataModel::vtkStaticCellLocator as StaticCellLocator; +pub use vtkCommonDataModel::vtkStaticPointLocator as StaticPointLocator; +pub use vtkCommonDataModel::vtkStaticPointLocator2D as StaticPointLocator2D; +pub use vtkCommonDataModel::vtkStructuredExtent as StructuredExtent; +pub use vtkCommonDataModel::vtkStructuredGrid as StructuredGrid; +pub use vtkCommonDataModel::vtkStructuredPoints as StructuredPoints; +pub use vtkCommonDataModel::vtkStructuredPointsCollection as StructuredPointsCollection; +pub use vtkCommonDataModel::vtkSuperquadric as Superquadric; +pub use vtkCommonDataModel::vtkTable as Table; +pub use vtkCommonDataModel::vtkTetra as Tetra; +pub use vtkCommonDataModel::vtkTree as Tree; +pub use vtkCommonDataModel::vtkTreeBFSIterator as TreeBFSIterator; +pub use vtkCommonDataModel::vtkTreeDFSIterator as TreeDFSIterator; +pub use vtkCommonDataModel::vtkTriQuadraticHexahedron as TriQuadraticHexahedron; +pub use vtkCommonDataModel::vtkTriQuadraticPyramid as TriQuadraticPyramid; +pub use vtkCommonDataModel::vtkTriangle as Triangle; +pub use vtkCommonDataModel::vtkTriangleStrip as TriangleStrip; +pub use vtkCommonDataModel::vtkUndirectedGraph as UndirectedGraph; +pub use vtkCommonDataModel::vtkUniformGrid as UniformGrid; +pub use vtkCommonDataModel::vtkUniformGridAMR as UniformGridAMR; +pub use vtkCommonDataModel::vtkUniformGridAMRDataIterator as UniformGridAMRDataIterator; +pub use vtkCommonDataModel::vtkUniformHyperTreeGrid as UniformHyperTreeGrid; +pub use vtkCommonDataModel::vtkUnstructuredGrid as UnstructuredGrid; +pub use vtkCommonDataModel::vtkUnstructuredGridCellIterator as UnstructuredGridCellIterator; +pub use vtkCommonDataModel::vtkVertex as Vertex; +pub use vtkCommonDataModel::vtkVertexListIterator as VertexListIterator; +pub use vtkCommonDataModel::vtkVoxel as Voxel; +pub use vtkCommonDataModel::vtkWedge as Wedge; +pub use vtkCommonDataModel::vtkXMLDataElement as XMLDataElement; +pub use vtkCommonExecutionModel::vtkAlgorithm as Algorithm; +pub use vtkCommonExecutionModel::vtkAlgorithmOutput as AlgorithmOutput; +pub use vtkCommonExecutionModel::vtkAnnotationLayersAlgorithm as AnnotationLayersAlgorithm; +pub use vtkCommonExecutionModel::vtkArrayDataAlgorithm as ArrayDataAlgorithm; +pub use vtkCommonExecutionModel::vtkCachedStreamingDemandDrivenPipeline as CachedStreamingDemandDrivenPipeline; +pub use vtkCommonExecutionModel::vtkCastToConcrete as CastToConcrete; +pub use vtkCommonExecutionModel::vtkCompositeDataPipeline as CompositeDataPipeline; +pub use vtkCommonExecutionModel::vtkCompositeDataSetAlgorithm as CompositeDataSetAlgorithm; +pub use vtkCommonExecutionModel::vtkDataObjectAlgorithm as DataObjectAlgorithm; +pub use vtkCommonExecutionModel::vtkDataSetAlgorithm as DataSetAlgorithm; +pub use vtkCommonExecutionModel::vtkDemandDrivenPipeline as DemandDrivenPipeline; +pub use vtkCommonExecutionModel::vtkDirectedGraphAlgorithm as DirectedGraphAlgorithm; +pub use vtkCommonExecutionModel::vtkEnsembleSource as EnsembleSource; +pub use vtkCommonExecutionModel::vtkExplicitStructuredGridAlgorithm as ExplicitStructuredGridAlgorithm; +pub use vtkCommonExecutionModel::vtkExtentRCBPartitioner as ExtentRCBPartitioner; +pub use vtkCommonExecutionModel::vtkExtentSplitter as ExtentSplitter; +pub use vtkCommonExecutionModel::vtkExtentTranslator as ExtentTranslator; +pub use vtkCommonExecutionModel::vtkGraphAlgorithm as GraphAlgorithm; +pub use vtkCommonExecutionModel::vtkHierarchicalBoxDataSetAlgorithm as HierarchicalBoxDataSetAlgorithm; +pub use vtkCommonExecutionModel::vtkImageToStructuredGrid as ImageToStructuredGrid; +pub use vtkCommonExecutionModel::vtkImageToStructuredPoints as ImageToStructuredPoints; +pub use vtkCommonExecutionModel::vtkMoleculeAlgorithm as MoleculeAlgorithm; +pub use vtkCommonExecutionModel::vtkMultiBlockDataSetAlgorithm as MultiBlockDataSetAlgorithm; +pub use vtkCommonExecutionModel::vtkMultiTimeStepAlgorithm as MultiTimeStepAlgorithm; +pub use vtkCommonExecutionModel::vtkNonOverlappingAMRAlgorithm as NonOverlappingAMRAlgorithm; +pub use vtkCommonExecutionModel::vtkOverlappingAMRAlgorithm as OverlappingAMRAlgorithm; +pub use vtkCommonExecutionModel::vtkPassInputTypeAlgorithm as PassInputTypeAlgorithm; +pub use vtkCommonExecutionModel::vtkPiecewiseFunctionAlgorithm as PiecewiseFunctionAlgorithm; +pub use vtkCommonExecutionModel::vtkPiecewiseFunctionShiftScale as PiecewiseFunctionShiftScale; +pub use vtkCommonExecutionModel::vtkPointSetAlgorithm as PointSetAlgorithm; +pub use vtkCommonExecutionModel::vtkPolyDataAlgorithm as PolyDataAlgorithm; +pub use vtkCommonExecutionModel::vtkProgressObserver as ProgressObserver; +pub use vtkCommonExecutionModel::vtkReaderExecutive as ReaderExecutive; +pub use vtkCommonExecutionModel::vtkRectilinearGridAlgorithm as RectilinearGridAlgorithm; +pub use vtkCommonExecutionModel::vtkSMPProgressObserver as SMPProgressObserver; +pub use vtkCommonExecutionModel::vtkSelectionAlgorithm as SelectionAlgorithm; +pub use vtkCommonExecutionModel::vtkSimpleScalarTree as SimpleScalarTree; +pub use vtkCommonExecutionModel::vtkSpanSpace as SpanSpace; +pub use vtkCommonExecutionModel::vtkSphereTree as SphereTree; +pub use vtkCommonExecutionModel::vtkStreamingDemandDrivenPipeline as StreamingDemandDrivenPipeline; +pub use vtkCommonExecutionModel::vtkStructuredGridAlgorithm as StructuredGridAlgorithm; +pub use vtkCommonExecutionModel::vtkTableAlgorithm as TableAlgorithm; +pub use vtkCommonExecutionModel::vtkThreadedCompositeDataPipeline as ThreadedCompositeDataPipeline; +pub use vtkCommonExecutionModel::vtkTreeAlgorithm as TreeAlgorithm; +pub use vtkCommonExecutionModel::vtkTrivialConsumer as TrivialConsumer; +pub use vtkCommonExecutionModel::vtkTrivialProducer as TrivialProducer; +pub use vtkCommonExecutionModel::vtkUndirectedGraphAlgorithm as UndirectedGraphAlgorithm; +pub use vtkCommonExecutionModel::vtkUniformGridAMRAlgorithm as UniformGridAMRAlgorithm; +pub use vtkCommonExecutionModel::vtkUniformGridPartitioner as UniformGridPartitioner; +pub use vtkCommonExecutionModel::vtkUnstructuredGridAlgorithm as UnstructuredGridAlgorithm; +pub use vtkCommonExecutionModel::vtkUnstructuredGridBaseAlgorithm as UnstructuredGridBaseAlgorithm; +pub use vtkCommonMath::vtkAmoebaMinimizer as AmoebaMinimizer; +pub use vtkCommonMath::vtkFFT as FFT; +pub use vtkCommonMath::vtkMatrix3x3 as Matrix3x3; +pub use vtkCommonMath::vtkMatrix4x4 as Matrix4x4; +pub use vtkCommonMath::vtkPolynomialSolversUnivariate as PolynomialSolversUnivariate; +pub use vtkCommonMath::vtkQuaternionInterpolator as QuaternionInterpolator; +pub use vtkCommonMath::vtkRungeKutta2 as RungeKutta2; +pub use vtkCommonMath::vtkRungeKutta4 as RungeKutta4; +pub use vtkCommonMath::vtkRungeKutta45 as RungeKutta45; +pub use vtkCommonMisc::vtkContourValues as ContourValues; +pub use vtkCommonMisc::vtkExprTkFunctionParser as ExprTkFunctionParser; +pub use vtkCommonMisc::vtkFunctionParser as FunctionParser; +pub use vtkCommonMisc::vtkHeap as Heap; +pub use vtkCommonMisc::vtkResourceFileLocator as ResourceFileLocator; +pub use vtkCommonSystem::vtkClientSocket as ClientSocket; +pub use vtkCommonSystem::vtkDirectory as Directory; +pub use vtkCommonSystem::vtkExecutableRunner as ExecutableRunner; +pub use vtkCommonSystem::vtkServerSocket as ServerSocket; +pub use vtkCommonSystem::vtkSocketCollection as SocketCollection; +pub use vtkCommonSystem::vtkThreadMessager as ThreadMessager; +pub use vtkCommonSystem::vtkTimerLog as TimerLog; +pub use vtkCommonTransforms::vtkCylindricalTransform as CylindricalTransform; +pub use vtkCommonTransforms::vtkGeneralTransform as GeneralTransform; +pub use vtkCommonTransforms::vtkIdentityTransform as IdentityTransform; +pub use vtkCommonTransforms::vtkLandmarkTransform as LandmarkTransform; +pub use vtkCommonTransforms::vtkMatrixToHomogeneousTransform as MatrixToHomogeneousTransform; +pub use vtkCommonTransforms::vtkMatrixToLinearTransform as MatrixToLinearTransform; +pub use vtkCommonTransforms::vtkPerspectiveTransform as PerspectiveTransform; +pub use vtkCommonTransforms::vtkSphericalTransform as SphericalTransform; +pub use vtkCommonTransforms::vtkThinPlateSplineTransform as ThinPlateSplineTransform; +pub use vtkCommonTransforms::vtkTransform as Transform; +pub use vtkCommonTransforms::vtkTransform2D as Transform2D; +pub use vtkCommonTransforms::vtkTransformCollection as TransformCollection; +pub use vtkFiltersSources::vtkArcSource as ArcSource; +pub use vtkFiltersSources::vtkArrowSource as ArrowSource; +pub use vtkFiltersSources::vtkCapsuleSource as CapsuleSource; +pub use vtkFiltersSources::vtkCellTypeSource as CellTypeSource; +pub use vtkFiltersSources::vtkConeSource as ConeSource; +pub use vtkFiltersSources::vtkCubeSource as CubeSource; +pub use vtkFiltersSources::vtkCylinderSource as CylinderSource; +pub use vtkFiltersSources::vtkDiagonalMatrixSource as DiagonalMatrixSource; +pub use vtkFiltersSources::vtkDiskSource as DiskSource; +pub use vtkFiltersSources::vtkEllipseArcSource as EllipseArcSource; +pub use vtkFiltersSources::vtkEllipticalButtonSource as EllipticalButtonSource; +pub use vtkFiltersSources::vtkFrustumSource as FrustumSource; +pub use vtkFiltersSources::vtkGlyphSource2D as GlyphSource2D; +pub use vtkFiltersSources::vtkGraphToPolyData as GraphToPolyData; +pub use vtkFiltersSources::vtkHyperTreeGridSource as HyperTreeGridSource; +pub use vtkFiltersSources::vtkLineSource as LineSource; +pub use vtkFiltersSources::vtkOutlineCornerFilter as OutlineCornerFilter; +pub use vtkFiltersSources::vtkOutlineCornerSource as OutlineCornerSource; +pub use vtkFiltersSources::vtkOutlineSource as OutlineSource; +pub use vtkFiltersSources::vtkParametricFunctionSource as ParametricFunctionSource; +pub use vtkFiltersSources::vtkPartitionedDataSetCollectionSource as PartitionedDataSetCollectionSource; +pub use vtkFiltersSources::vtkPartitionedDataSetSource as PartitionedDataSetSource; +pub use vtkFiltersSources::vtkPlaneSource as PlaneSource; +pub use vtkFiltersSources::vtkPlatonicSolidSource as PlatonicSolidSource; +pub use vtkFiltersSources::vtkPointHandleSource as PointHandleSource; +pub use vtkFiltersSources::vtkPointSource as PointSource; +pub use vtkFiltersSources::vtkPolyLineSource as PolyLineSource; +pub use vtkFiltersSources::vtkPolyPointSource as PolyPointSource; +pub use vtkFiltersSources::vtkProgrammableDataObjectSource as ProgrammableDataObjectSource; +pub use vtkFiltersSources::vtkProgrammableSource as ProgrammableSource; +pub use vtkFiltersSources::vtkRandomHyperTreeGridSource as RandomHyperTreeGridSource; +pub use vtkFiltersSources::vtkRectangularButtonSource as RectangularButtonSource; +pub use vtkFiltersSources::vtkRegularPolygonSource as RegularPolygonSource; +pub use vtkFiltersSources::vtkSelectionSource as SelectionSource; +pub use vtkFiltersSources::vtkSphereSource as SphereSource; +pub use vtkFiltersSources::vtkSuperquadricSource as SuperquadricSource; +pub use vtkFiltersSources::vtkTessellatedBoxSource as TessellatedBoxSource; +pub use vtkFiltersSources::vtkTextSource as TextSource; +pub use vtkFiltersSources::vtkTexturedSphereSource as TexturedSphereSource; +pub use vtkFiltersSources::vtkUniformHyperTreeGridSource as UniformHyperTreeGridSource; +pub mod prelude { + pub use crate::vtkCommonColor::*; + pub use crate::vtkCommonComputationalGeometry::*; + pub use crate::vtkCommonCore::*; + pub use crate::vtkCommonDataModel::*; + pub use crate::vtkCommonExecutionModel::*; + pub use crate::vtkCommonMath::*; + pub use crate::vtkCommonMisc::*; + pub use crate::vtkCommonSystem::*; + pub use crate::vtkCommonTransforms::*; + pub use crate::vtkFiltersSources::*; +} diff --git a/vtk-rs-9.1/src/vtkCommonArchive.rs b/vtk-rs-9.1/src/vtkCommonArchive.rs index c0a53bf..070b0b3 100644 --- a/vtk-rs-9.1/src/vtkCommonArchive.rs +++ b/vtk-rs-9.1/src/vtkCommonArchive.rs @@ -27,6 +27,28 @@ impl vtkBufferedArchiver { unsafe { vtkBufferedArchiver_get_ptr(self.0) } } } +impl crate::vtkCommonCore::VtkArchiver for vtkBufferedArchiver { + fn set_archive_name(&self, name: &str) { + unsafe extern "C" { + fn vtkBufferedArchiver_set_archive_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe { vtkBufferedArchiver_set_archive_name(self.0, c_name.as_ptr()) } + } + fn get_archive_name(&self) -> &str { + unsafe extern "C" { + fn vtkBufferedArchiver_get_archive_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtkBufferedArchiver_get_archive_name(self.0) }; + if ptr.is_null() { return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} impl std::default::Default for vtkBufferedArchiver { fn default() -> Self { Self::new() @@ -51,6 +73,13 @@ fn test_vtkBufferedArchiver_create_drop() { let new_obj = vtkBufferedArchiver(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } +#[test] +fn test_vtkBufferedArchiver_set_archive_name() { + use crate::vtkCommonCore::VtkArchiver; + let obj = vtkBufferedArchiver::new(); + obj.set_archive_name("test_archive"); + assert_eq!(obj.get_archive_name(), "test_archive"); +} /// Writes an archive to several buffers /// /// @@ -81,6 +110,28 @@ impl vtkPartitionedArchiver { unsafe { vtkPartitionedArchiver_get_ptr(self.0) } } } +impl crate::vtkCommonCore::VtkArchiver for vtkPartitionedArchiver { + fn set_archive_name(&self, name: &str) { + unsafe extern "C" { + fn vtkPartitionedArchiver_set_archive_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe { vtkPartitionedArchiver_set_archive_name(self.0, c_name.as_ptr()) } + } + fn get_archive_name(&self) -> &str { + unsafe extern "C" { + fn vtkPartitionedArchiver_get_archive_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtkPartitionedArchiver_get_archive_name(self.0) }; + if ptr.is_null() { return ""; } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} impl std::default::Default for vtkPartitionedArchiver { fn default() -> Self { Self::new() @@ -105,3 +156,10 @@ fn test_vtkPartitionedArchiver_create_drop() { let new_obj = vtkPartitionedArchiver(ptr); assert!(unsafe { new_obj._get_ptr().is_null() }); } +#[test] +fn test_vtkPartitionedArchiver_set_archive_name() { + use crate::vtkCommonCore::VtkArchiver; + let obj = vtkPartitionedArchiver::new(); + obj.set_archive_name("test_archive"); + assert_eq!(obj.get_archive_name(), "test_archive"); +} diff --git a/vtk-rs-9.1/src/vtkCommonColor.rs b/vtk-rs-9.1/src/vtkCommonColor.rs index 4a38677..86859a6 100644 --- a/vtk-rs-9.1/src/vtkCommonColor.rs +++ b/vtk-rs-9.1/src/vtkCommonColor.rs @@ -1,3 +1,192 @@ +pub trait VtkColorSeries { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_color_scheme(&mut self, scheme: core::ffi::c_int) -> (); + fn get_number_of_color_schemes(&mut self) -> core::ffi::c_int; + fn get_color_scheme(&mut self) -> core::ffi::c_int; + fn get_number_of_colors(&mut self) -> core::ffi::c_int; + fn set_number_of_colors(&mut self, numColors: core::ffi::c_int) -> (); + fn remove_color(&mut self, index: core::ffi::c_int) -> (); + fn clear_colors(&mut self) -> (); + fn deep_copy(&mut self, chartColors: *mut core::ffi::c_void) -> (); + fn build_lookup_table( + &mut self, + lkup: *mut core::ffi::c_void, + lutIndexing: core::ffi::c_int, + ) -> (); + fn create_lookup_table( + &mut self, + lutIndexing: core::ffi::c_int, + ) -> *mut core::ffi::c_void; +} +pub trait VtkNamedColors { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_colors(&mut self) -> core::ffi::c_int; + fn reset_colors(&mut self) -> (); +} +impl VtkColorSeries for vtkColorSeries { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_new(self.0) } + } + fn set_color_scheme(&mut self, scheme: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_color_series_set_color_scheme( + sself: *mut core::ffi::c_void, + scheme: core::ffi::c_int, + ); + } + unsafe { vtk_color_series_set_color_scheme(self.0, scheme) } + } + fn get_number_of_color_schemes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_color_series_get_number_of_color_schemes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_color_series_get_number_of_color_schemes(self.0) } + } + fn get_color_scheme(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_color_series_get_color_scheme( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_color_series_get_color_scheme(self.0) } + } + fn get_number_of_colors(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_color_series_get_number_of_colors( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_color_series_get_number_of_colors(self.0) } + } + fn set_number_of_colors(&mut self, numColors: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_color_series_set_number_of_colors( + sself: *mut core::ffi::c_void, + numColors: core::ffi::c_int, + ); + } + unsafe { vtk_color_series_set_number_of_colors(self.0, numColors) } + } + fn remove_color(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_color_series_remove_color( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_color_series_remove_color(self.0, index) } + } + fn clear_colors(&mut self) -> () { + unsafe extern "C" { + fn vtk_color_series_clear_colors(sself: *mut core::ffi::c_void); + } + unsafe { vtk_color_series_clear_colors(self.0) } + } + fn deep_copy(&mut self, chartColors: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_color_series_deep_copy( + sself: *mut core::ffi::c_void, + chartColors: *mut core::ffi::c_void, + ); + } + unsafe { vtk_color_series_deep_copy(self.0, chartColors) } + } + fn build_lookup_table( + &mut self, + lkup: *mut core::ffi::c_void, + lutIndexing: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_color_series_build_lookup_table( + sself: *mut core::ffi::c_void, + lkup: *mut core::ffi::c_void, + lutIndexing: core::ffi::c_int, + ); + } + unsafe { vtk_color_series_build_lookup_table(self.0, lkup, lutIndexing) } + } + fn create_lookup_table( + &mut self, + lutIndexing: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_color_series_create_lookup_table( + sself: *mut core::ffi::c_void, + lutIndexing: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_color_series_create_lookup_table(self.0, lutIndexing) } + } +} +impl VtkNamedColors for vtkNamedColors { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_named_colors_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_named_colors_new(self.0) } + } + fn get_number_of_colors(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_named_colors_get_number_of_colors( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_named_colors_get_number_of_colors(self.0) } + } + fn reset_colors(&mut self) -> () { + unsafe extern "C" { + fn vtk_named_colors_reset_colors(sself: *mut core::ffi::c_void); + } + unsafe { vtk_named_colors_reset_colors(self.0) } + } +} /// stores a list of colors. /// /// @@ -30,22 +219,13 @@ #[allow(non_camel_case_types)] pub struct vtkColorSeries(*mut core::ffi::c_void); impl vtkColorSeries { - /// Creates a new [vtkColorSeries] wrapped inside `vtkNew` + /// Creates a new [vtkColorSeries] via `vtkColorSeries::New()` #[doc(alias = "vtkColorSeries")] pub fn new() -> Self { unsafe extern "C" { fn vtkColorSeries_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkColorSeries_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkColorSeries_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkColorSeries_get_ptr(self.0) } + Self(unsafe { vtkColorSeries_new() }) } } impl std::default::Default for vtkColorSeries { @@ -65,12 +245,8 @@ impl Drop for vtkColorSeries { #[test] fn test_vtkColorSeries_create_drop() { let obj = vtkColorSeries::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkColorSeries(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A class holding colors and their names. /// @@ -125,22 +301,13 @@ fn test_vtkColorSeries_create_drop() { #[allow(non_camel_case_types)] pub struct vtkNamedColors(*mut core::ffi::c_void); impl vtkNamedColors { - /// Creates a new [vtkNamedColors] wrapped inside `vtkNew` + /// Creates a new [vtkNamedColors] via `vtkNamedColors::New()` #[doc(alias = "vtkNamedColors")] pub fn new() -> Self { unsafe extern "C" { fn vtkNamedColors_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkNamedColors_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkNamedColors_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkNamedColors_get_ptr(self.0) } + Self(unsafe { vtkNamedColors_new() }) } } impl std::default::Default for vtkNamedColors { @@ -160,10 +327,6 @@ impl Drop for vtkNamedColors { #[test] fn test_vtkNamedColors_create_drop() { let obj = vtkNamedColors::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkNamedColors(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs b/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs index dd6b563..f9094b1 100644 --- a/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs +++ b/vtk-rs-9.1/src/vtkCommonComputationalGeometry.rs @@ -1,3 +1,2258 @@ +pub trait VtkBilinearQuadIntersection {} +pub trait VtkCardinalSpline { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn compute(&mut self) -> (); + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double; + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> (); +} +pub trait VtkKochanekSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn compute(&mut self) -> (); + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double; + fn set_default_bias(&mut self, _arg: core::ffi::c_double) -> (); + fn get_default_bias(&mut self) -> core::ffi::c_double; + fn set_default_tension(&mut self, _arg: core::ffi::c_double) -> (); + fn get_default_tension(&mut self) -> core::ffi::c_double; + fn set_default_continuity(&mut self, _arg: core::ffi::c_double) -> (); + fn get_default_continuity(&mut self) -> core::ffi::c_double; + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> (); +} +pub trait VtkParametricBohemianDome { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_a(&mut self) -> core::ffi::c_double; + fn set_a(&mut self, _arg: core::ffi::c_double) -> (); + fn get_b(&mut self) -> core::ffi::c_double; + fn set_b(&mut self, _arg: core::ffi::c_double) -> (); + fn get_c(&mut self) -> core::ffi::c_double; + fn set_c(&mut self, _arg: core::ffi::c_double) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricBour { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricBoy { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_z_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_scale(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricCatalanMinimal { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricConicSpiral { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_a(&mut self, _arg: core::ffi::c_double) -> (); + fn get_a(&mut self) -> core::ffi::c_double; + fn set_b(&mut self, _arg: core::ffi::c_double) -> (); + fn get_b(&mut self) -> core::ffi::c_double; + fn set_c(&mut self, _arg: core::ffi::c_double) -> (); + fn get_c(&mut self) -> core::ffi::c_double; + fn set_n(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricCrossCap { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricDini { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_a(&mut self, _arg: core::ffi::c_double) -> (); + fn get_a(&mut self) -> core::ffi::c_double; + fn set_b(&mut self, _arg: core::ffi::c_double) -> (); + fn get_b(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricEllipsoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_radius(&mut self) -> core::ffi::c_double; + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_radius(&mut self) -> core::ffi::c_double; + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_radius(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricEnneper { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricFigure8Klein { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_minimum_u(&mut self, _arg: core::ffi::c_double) -> (); + fn get_minimum_u(&mut self) -> core::ffi::c_double; + fn set_maximum_u(&mut self, _arg: core::ffi::c_double) -> (); + fn get_maximum_u(&mut self) -> core::ffi::c_double; + fn set_minimum_v(&mut self, _arg: core::ffi::c_double) -> (); + fn get_minimum_v(&mut self) -> core::ffi::c_double; + fn set_maximum_v(&mut self, _arg: core::ffi::c_double) -> (); + fn get_maximum_v(&mut self) -> core::ffi::c_double; + fn set_minimum_w(&mut self, _arg: core::ffi::c_double) -> (); + fn get_minimum_w(&mut self) -> core::ffi::c_double; + fn set_maximum_w(&mut self, _arg: core::ffi::c_double) -> (); + fn get_maximum_w(&mut self) -> core::ffi::c_double; + fn set_join_u(&mut self, _arg: core::ffi::c_int) -> (); + fn get_join_u_min_value(&mut self) -> core::ffi::c_int; + fn get_join_u_max_value(&mut self) -> core::ffi::c_int; + fn get_join_u(&mut self) -> core::ffi::c_int; + fn join_u_on(&mut self) -> (); + fn join_u_off(&mut self) -> (); + fn set_join_v(&mut self, _arg: core::ffi::c_int) -> (); + fn get_join_v_min_value(&mut self) -> core::ffi::c_int; + fn get_join_v_max_value(&mut self) -> core::ffi::c_int; + fn get_join_v(&mut self) -> core::ffi::c_int; + fn join_v_on(&mut self) -> (); + fn join_v_off(&mut self) -> (); + fn set_join_w(&mut self, _arg: core::ffi::c_int) -> (); + fn get_join_w_min_value(&mut self) -> core::ffi::c_int; + fn get_join_w_max_value(&mut self) -> core::ffi::c_int; + fn get_join_w(&mut self) -> core::ffi::c_int; + fn join_w_on(&mut self) -> (); + fn join_w_off(&mut self) -> (); + fn set_twist_u(&mut self, _arg: core::ffi::c_int) -> (); + fn get_twist_u_min_value(&mut self) -> core::ffi::c_int; + fn get_twist_u_max_value(&mut self) -> core::ffi::c_int; + fn get_twist_u(&mut self) -> core::ffi::c_int; + fn twist_u_on(&mut self) -> (); + fn twist_u_off(&mut self) -> (); + fn set_twist_v(&mut self, _arg: core::ffi::c_int) -> (); + fn get_twist_v_min_value(&mut self) -> core::ffi::c_int; + fn get_twist_v_max_value(&mut self) -> core::ffi::c_int; + fn get_twist_v(&mut self) -> core::ffi::c_int; + fn twist_v_on(&mut self) -> (); + fn twist_v_off(&mut self) -> (); + fn set_twist_w(&mut self, _arg: core::ffi::c_int) -> (); + fn get_twist_w_min_value(&mut self) -> core::ffi::c_int; + fn get_twist_w_max_value(&mut self) -> core::ffi::c_int; + fn get_twist_w(&mut self) -> core::ffi::c_int; + fn twist_w_on(&mut self) -> (); + fn twist_w_off(&mut self) -> (); + fn set_clockwise_ordering(&mut self, _arg: core::ffi::c_int) -> (); + fn get_clockwise_ordering_min_value(&mut self) -> core::ffi::c_int; + fn get_clockwise_ordering_max_value(&mut self) -> core::ffi::c_int; + fn get_clockwise_ordering(&mut self) -> core::ffi::c_int; + fn clockwise_ordering_on(&mut self) -> (); + fn clockwise_ordering_off(&mut self) -> (); + fn set_derivatives_available(&mut self, _arg: core::ffi::c_int) -> (); + fn get_derivatives_available_min_value(&mut self) -> core::ffi::c_int; + fn get_derivatives_available_max_value(&mut self) -> core::ffi::c_int; + fn get_derivatives_available(&mut self) -> core::ffi::c_int; + fn derivatives_available_on(&mut self) -> (); + fn derivatives_available_off(&mut self) -> (); +} +pub trait VtkParametricHenneberg { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricKlein { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricKuen { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_delta_v_0(&mut self, _arg: core::ffi::c_double) -> (); + fn get_delta_v_0(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricMobius { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricPluckerConoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_n(&mut self) -> core::ffi::c_int; + fn set_n(&mut self, _arg: core::ffi::c_int) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricPseudosphere { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricRandomHills { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_hills(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_hills(&mut self) -> core::ffi::c_int; + fn set_hill_x_variance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_hill_x_variance(&mut self) -> core::ffi::c_double; + fn set_hill_y_variance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_hill_y_variance(&mut self) -> core::ffi::c_double; + fn set_hill_amplitude(&mut self, _arg: core::ffi::c_double) -> (); + fn get_hill_amplitude(&mut self) -> core::ffi::c_double; + fn set_random_seed(&mut self, _arg: core::ffi::c_int) -> (); + fn get_random_seed(&mut self) -> core::ffi::c_int; + fn set_allow_random_generation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_allow_random_generation_min_value(&mut self) -> core::ffi::c_int; + fn get_allow_random_generation_max_value(&mut self) -> core::ffi::c_int; + fn get_allow_random_generation(&mut self) -> core::ffi::c_int; + fn allow_random_generation_on(&mut self) -> (); + fn allow_random_generation_off(&mut self) -> (); + fn set_x_variance_scale_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_variance_scale_factor(&mut self) -> core::ffi::c_double; + fn set_y_variance_scale_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_variance_scale_factor(&mut self) -> core::ffi::c_double; + fn set_amplitude_scale_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_amplitude_scale_factor(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricRoman { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_x_spline(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_y_spline(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_z_spline(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_x_spline(&mut self) -> *mut core::ffi::c_void; + fn get_y_spline(&mut self) -> *mut core::ffi::c_void; + fn get_z_spline(&mut self) -> *mut core::ffi::c_void; + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points(&mut self, numPts: core::ffi::c_longlong) -> (); + fn set_point( + &mut self, + index: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_closed(&mut self, _arg: core::ffi::c_int) -> (); + fn get_closed(&mut self) -> core::ffi::c_int; + fn closed_on(&mut self) -> (); + fn closed_off(&mut self) -> (); + fn set_parameterize_by_length(&mut self, _arg: core::ffi::c_int) -> (); + fn get_parameterize_by_length(&mut self) -> core::ffi::c_int; + fn parameterize_by_length_on(&mut self) -> (); + fn parameterize_by_length_off(&mut self) -> (); + fn set_left_constraint(&mut self, _arg: core::ffi::c_int) -> (); + fn get_left_constraint_min_value(&mut self) -> core::ffi::c_int; + fn get_left_constraint_max_value(&mut self) -> core::ffi::c_int; + fn get_left_constraint(&mut self) -> core::ffi::c_int; + fn set_right_constraint(&mut self, _arg: core::ffi::c_int) -> (); + fn get_right_constraint_min_value(&mut self) -> core::ffi::c_int; + fn get_right_constraint_max_value(&mut self) -> core::ffi::c_int; + fn get_right_constraint(&mut self) -> core::ffi::c_int; + fn set_left_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_left_value(&mut self) -> core::ffi::c_double; + fn set_right_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_right_value(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricSuperEllipsoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_radius(&mut self) -> core::ffi::c_double; + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_radius(&mut self) -> core::ffi::c_double; + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_radius(&mut self) -> core::ffi::c_double; + fn set_n_1(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n_1(&mut self) -> core::ffi::c_double; + fn set_n_2(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n_2(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricSuperToroid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn set_ring_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_ring_radius(&mut self) -> core::ffi::c_double; + fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_cross_section_radius(&mut self) -> core::ffi::c_double; + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_radius(&mut self) -> core::ffi::c_double; + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_radius(&mut self) -> core::ffi::c_double; + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_radius(&mut self) -> core::ffi::c_double; + fn set_n_1(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n_1(&mut self) -> core::ffi::c_double; + fn set_n_2(&mut self, _arg: core::ffi::c_double) -> (); + fn get_n_2(&mut self) -> core::ffi::c_double; +} +pub trait VtkParametricTorus { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_ring_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_ring_radius(&mut self) -> core::ffi::c_double; + fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_cross_section_radius(&mut self) -> core::ffi::c_double; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +impl VtkCardinalSpline for vtkCardinalSpline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cardinal_spline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cardinal_spline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cardinal_spline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cardinal_spline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cardinal_spline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cardinal_spline_new_instance(self.0) } + } + fn compute(&mut self) -> () { + unsafe extern "C" { + fn vtk_cardinal_spline_compute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cardinal_spline_compute(self.0) } + } + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cardinal_spline_evaluate( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_cardinal_spline_evaluate(self.0, t) } + } + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cardinal_spline_deep_copy( + sself: *mut core::ffi::c_void, + s: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cardinal_spline_deep_copy(self.0, s) } + } +} +impl VtkKochanekSpline for vtkKochanekSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kochanek_spline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kochanek_spline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kochanek_spline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kochanek_spline_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kochanek_spline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kochanek_spline_new(self.0) } + } + fn compute(&mut self) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_compute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kochanek_spline_compute(self.0) } + } + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kochanek_spline_evaluate( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_kochanek_spline_evaluate(self.0, t) } + } + fn set_default_bias(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_set_default_bias( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_kochanek_spline_set_default_bias(self.0, _arg) } + } + fn get_default_bias(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kochanek_spline_get_default_bias( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kochanek_spline_get_default_bias(self.0) } + } + fn set_default_tension(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_set_default_tension( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_kochanek_spline_set_default_tension(self.0, _arg) } + } + fn get_default_tension(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kochanek_spline_get_default_tension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kochanek_spline_get_default_tension(self.0) } + } + fn set_default_continuity(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_set_default_continuity( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_kochanek_spline_set_default_continuity(self.0, _arg) } + } + fn get_default_continuity(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kochanek_spline_get_default_continuity( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kochanek_spline_get_default_continuity(self.0) } + } + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kochanek_spline_deep_copy( + sself: *mut core::ffi::c_void, + s: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kochanek_spline_deep_copy(self.0, s) } + } +} +impl VtkParametricBohemianDome for vtkParametricBohemianDome { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bohemian_dome_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bohemian_dome_new_instance(self.0) } + } + fn get_a(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_get_a( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_bohemian_dome_get_a(self.0) } + } + fn set_a(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_set_a( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_bohemian_dome_set_a(self.0, _arg) } + } + fn get_b(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_get_b( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_bohemian_dome_get_b(self.0) } + } + fn set_b(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_set_b( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_bohemian_dome_set_b(self.0, _arg) } + } + fn get_c(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_get_c( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_bohemian_dome_get_c(self.0) } + } + fn set_c(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_set_c( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_bohemian_dome_set_c(self.0, _arg) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bohemian_dome_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_bohemian_dome_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_bohemian_dome_get_dimension(self.0) } + } +} +impl VtkParametricBour for vtkParametricBour { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bour_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bour_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bour_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bour_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_bour_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_bour_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_bour_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_bour_get_dimension(self.0) } + } +} +impl VtkParametricBoy for vtkParametricBoy { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_boy_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_boy_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_boy_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_boy_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_boy_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_boy_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_boy_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_boy_get_dimension(self.0) } + } + fn set_z_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_boy_set_z_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_boy_set_z_scale(self.0, _arg) } + } + fn get_z_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_boy_get_z_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_boy_get_z_scale(self.0) } + } +} +impl VtkParametricCatalanMinimal for vtkParametricCatalanMinimal { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_catalan_minimal_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_catalan_minimal_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_catalan_minimal_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_catalan_minimal_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_catalan_minimal_get_dimension(self.0) } + } +} +impl VtkParametricConicSpiral for vtkParametricConicSpiral { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_conic_spiral_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_conic_spiral_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_conic_spiral_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_conic_spiral_get_dimension(self.0) } + } + fn set_a(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_set_a( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_set_a(self.0, _arg) } + } + fn get_a(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_a( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_get_a(self.0) } + } + fn set_b(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_set_b( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_set_b(self.0, _arg) } + } + fn get_b(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_b( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_get_b(self.0) } + } + fn set_c(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_set_c( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_set_c(self.0, _arg) } + } + fn get_c(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_c( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_get_c(self.0) } + } + fn set_n(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_set_n( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_conic_spiral_set_n(self.0, _arg) } + } + fn get_n(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_conic_spiral_get_n( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_conic_spiral_get_n(self.0) } + } +} +impl VtkParametricCrossCap for vtkParametricCrossCap { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_cross_cap_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_cross_cap_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_cross_cap_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_cross_cap_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_cross_cap_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_cross_cap_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_cross_cap_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_cross_cap_get_dimension(self.0) } + } +} +impl VtkParametricDini for vtkParametricDini { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_dini_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_dini_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_dini_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_dini_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_dini_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_dini_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_dini_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_dini_get_dimension(self.0) } + } + fn set_a(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_dini_set_a( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_dini_set_a(self.0, _arg) } + } + fn get_a(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_dini_get_a( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_dini_get_a(self.0) } + } + fn set_b(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_dini_set_b( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_dini_set_b(self.0, _arg) } + } + fn get_b(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_dini_get_b( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_dini_get_b(self.0) } + } +} +impl VtkParametricEllipsoid for vtkParametricEllipsoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_ellipsoid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_ellipsoid_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_ellipsoid_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_ellipsoid_get_dimension(self.0) } + } + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_set_x_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_ellipsoid_set_x_radius(self.0, _arg) } + } + fn get_x_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_get_x_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_ellipsoid_get_x_radius(self.0) } + } + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_set_y_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_ellipsoid_set_y_radius(self.0, _arg) } + } + fn get_y_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_get_y_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_ellipsoid_get_y_radius(self.0) } + } + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_set_z_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_ellipsoid_set_z_radius(self.0, _arg) } + } + fn get_z_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_ellipsoid_get_z_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_ellipsoid_get_z_radius(self.0) } + } +} +impl VtkParametricEnneper for vtkParametricEnneper { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_enneper_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_enneper_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_enneper_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_enneper_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_enneper_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_enneper_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_enneper_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_enneper_get_dimension(self.0) } + } +} +impl VtkParametricFigure8Klein for vtkParametricFigure8Klein { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_figure_8_klein_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_figure_8_klein_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_figure_8_klein_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_figure_8_klein_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_figure_8_klein_get_radius(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_figure_8_klein_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_figure_8_klein_get_dimension(self.0) } + } +} +impl VtkParametricHenneberg for vtkParametricHenneberg { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_henneberg_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_henneberg_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_henneberg_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_henneberg_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_henneberg_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_henneberg_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_henneberg_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_henneberg_get_dimension(self.0) } + } +} +impl VtkParametricKlein for vtkParametricKlein { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_klein_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_klein_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_klein_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_klein_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_klein_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_klein_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_klein_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_klein_get_dimension(self.0) } + } +} +impl VtkParametricKuen for vtkParametricKuen { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_kuen_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_kuen_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_kuen_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_kuen_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_kuen_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_kuen_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_kuen_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_kuen_get_dimension(self.0) } + } + fn set_delta_v_0(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_kuen_set_delta_v_0( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_kuen_set_delta_v_0(self.0, _arg) } + } + fn get_delta_v_0(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_kuen_get_delta_v_0( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_kuen_get_delta_v_0(self.0) } + } +} +impl VtkParametricMobius for vtkParametricMobius { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_mobius_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_mobius_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_mobius_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_mobius_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_mobius_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_mobius_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_mobius_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_mobius_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_mobius_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_mobius_get_radius(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_mobius_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_mobius_get_dimension(self.0) } + } +} +impl VtkParametricPluckerConoid for vtkParametricPluckerConoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_plucker_conoid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_plucker_conoid_new_instance(self.0) } + } + fn get_n(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_get_n( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_plucker_conoid_get_n(self.0) } + } + fn set_n(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_set_n( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_plucker_conoid_set_n(self.0, _arg) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_plucker_conoid_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_plucker_conoid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_plucker_conoid_get_dimension(self.0) } + } +} +impl VtkParametricPseudosphere for vtkParametricPseudosphere { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_pseudosphere_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_pseudosphere_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_pseudosphere_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_pseudosphere_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_pseudosphere_get_dimension(self.0) } + } +} +impl VtkParametricRandomHills for vtkParametricRandomHills { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_random_hills_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_random_hills_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_random_hills_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_random_hills_new_instance(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_random_hills_get_dimension(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_random_hills_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_random_hills_new(self.0) } + } + fn set_number_of_hills(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_number_of_hills( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_random_hills_set_number_of_hills(self.0, _arg) } + } + fn get_number_of_hills(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_number_of_hills( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_random_hills_get_number_of_hills(self.0) } + } + fn set_hill_x_variance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_hill_x_variance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_hill_x_variance(self.0, _arg) } + } + fn get_hill_x_variance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_hill_x_variance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_hill_x_variance(self.0) } + } + fn set_hill_y_variance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_hill_y_variance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_hill_y_variance(self.0, _arg) } + } + fn get_hill_y_variance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_hill_y_variance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_hill_y_variance(self.0) } + } + fn set_hill_amplitude(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_hill_amplitude( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_hill_amplitude(self.0, _arg) } + } + fn get_hill_amplitude(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_hill_amplitude( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_hill_amplitude(self.0) } + } + fn set_random_seed(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_random_seed( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_random_hills_set_random_seed(self.0, _arg) } + } + fn get_random_seed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_random_seed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_random_hills_get_random_seed(self.0) } + } + fn set_allow_random_generation(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_allow_random_generation( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_random_hills_set_allow_random_generation(self.0, _arg) } + } + fn get_allow_random_generation_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_allow_random_generation_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_random_hills_get_allow_random_generation_min_value(self.0) + } + } + fn get_allow_random_generation_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_allow_random_generation_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_random_hills_get_allow_random_generation_max_value(self.0) + } + } + fn get_allow_random_generation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_allow_random_generation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_random_hills_get_allow_random_generation(self.0) } + } + fn allow_random_generation_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_allow_random_generation_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_random_hills_allow_random_generation_on(self.0) } + } + fn allow_random_generation_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_allow_random_generation_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_random_hills_allow_random_generation_off(self.0) } + } + fn set_x_variance_scale_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_x_variance_scale_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_x_variance_scale_factor(self.0, _arg) } + } + fn get_x_variance_scale_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_x_variance_scale_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_x_variance_scale_factor(self.0) } + } + fn set_y_variance_scale_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_y_variance_scale_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_y_variance_scale_factor(self.0, _arg) } + } + fn get_y_variance_scale_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_y_variance_scale_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_y_variance_scale_factor(self.0) } + } + fn set_amplitude_scale_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_random_hills_set_amplitude_scale_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_random_hills_set_amplitude_scale_factor(self.0, _arg) } + } + fn get_amplitude_scale_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_random_hills_get_amplitude_scale_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_random_hills_get_amplitude_scale_factor(self.0) } + } +} +impl VtkParametricRoman for vtkParametricRoman { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_roman_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_roman_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_roman_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_roman_new_instance(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_roman_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_roman_get_dimension(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_roman_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_roman_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_roman_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_roman_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_roman_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_roman_get_radius(self.0) } + } +} +impl VtkParametricSpline for vtkParametricSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_dimension(self.0) } + } + fn set_x_spline(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_x_spline( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_set_x_spline(self.0, p0) } + } + fn set_y_spline(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_y_spline( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_set_y_spline(self.0, p0) } + } + fn set_z_spline(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_z_spline( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_set_z_spline(self.0, p0) } + } + fn get_x_spline(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_get_x_spline( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_get_x_spline(self.0) } + } + fn get_y_spline(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_get_y_spline( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_get_y_spline(self.0) } + } + fn get_z_spline(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_get_z_spline( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_get_z_spline(self.0) } + } + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_points( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_set_points(self.0, p0) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_spline_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_spline_get_points(self.0) } + } + fn set_number_of_points(&mut self, numPts: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_number_of_points( + sself: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ); + } + unsafe { vtk_parametric_spline_set_number_of_points(self.0, numPts) } + } + fn set_point( + &mut self, + index: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_point( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_spline_set_point(self.0, index, x, y, z) } + } + fn set_closed(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_closed( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_spline_set_closed(self.0, _arg) } + } + fn get_closed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_closed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_closed(self.0) } + } + fn closed_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_closed_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_parametric_spline_closed_on(self.0) } + } + fn closed_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_closed_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_parametric_spline_closed_off(self.0) } + } + fn set_parameterize_by_length(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_parameterize_by_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_spline_set_parameterize_by_length(self.0, _arg) } + } + fn get_parameterize_by_length(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_parameterize_by_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_parameterize_by_length(self.0) } + } + fn parameterize_by_length_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_parameterize_by_length_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_parameterize_by_length_on(self.0) } + } + fn parameterize_by_length_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_parameterize_by_length_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_spline_parameterize_by_length_off(self.0) } + } + fn set_left_constraint(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_left_constraint( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_spline_set_left_constraint(self.0, _arg) } + } + fn get_left_constraint_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_left_constraint_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_left_constraint_min_value(self.0) } + } + fn get_left_constraint_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_left_constraint_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_left_constraint_max_value(self.0) } + } + fn get_left_constraint(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_left_constraint( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_left_constraint(self.0) } + } + fn set_right_constraint(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_right_constraint( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_spline_set_right_constraint(self.0, _arg) } + } + fn get_right_constraint_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_right_constraint_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_right_constraint_min_value(self.0) } + } + fn get_right_constraint_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_right_constraint_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_right_constraint_max_value(self.0) } + } + fn get_right_constraint(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_spline_get_right_constraint( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_spline_get_right_constraint(self.0) } + } + fn set_left_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_left_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_spline_set_left_value(self.0, _arg) } + } + fn get_left_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_spline_get_left_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_spline_get_left_value(self.0) } + } + fn set_right_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_spline_set_right_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_spline_set_right_value(self.0, _arg) } + } + fn get_right_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_spline_get_right_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_spline_get_right_value(self.0) } + } +} +impl VtkParametricSuperEllipsoid for vtkParametricSuperEllipsoid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_ellipsoid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_ellipsoid_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_ellipsoid_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_super_ellipsoid_get_dimension(self.0) } + } + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_x_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_x_radius(self.0, _arg) } + } + fn get_x_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_x_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_x_radius(self.0) } + } + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_y_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_y_radius(self.0, _arg) } + } + fn get_y_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_y_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_y_radius(self.0) } + } + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_z_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_z_radius(self.0, _arg) } + } + fn get_z_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_z_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_z_radius(self.0) } + } + fn set_n_1(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_n_1( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_n_1(self.0, _arg) } + } + fn get_n_1(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_n_1( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_n_1(self.0) } + } + fn set_n_2(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_set_n_2( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_ellipsoid_set_n_2(self.0, _arg) } + } + fn get_n_2(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_ellipsoid_get_n_2( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_ellipsoid_get_n_2(self.0) } + } +} +impl VtkParametricSuperToroid for vtkParametricSuperToroid { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_toroid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_toroid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_toroid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_toroid_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_super_toroid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_super_toroid_new(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_super_toroid_get_dimension(self.0) } + } + fn set_ring_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_ring_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_ring_radius(self.0, _arg) } + } + fn get_ring_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_ring_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_ring_radius(self.0) } + } + fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_cross_section_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_cross_section_radius(self.0, _arg) } + } + fn get_cross_section_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_cross_section_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_cross_section_radius(self.0) } + } + fn set_x_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_x_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_x_radius(self.0, _arg) } + } + fn get_x_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_x_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_x_radius(self.0) } + } + fn set_y_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_y_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_y_radius(self.0, _arg) } + } + fn get_y_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_y_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_y_radius(self.0) } + } + fn set_z_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_z_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_z_radius(self.0, _arg) } + } + fn get_z_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_z_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_z_radius(self.0) } + } + fn set_n_1(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_n_1( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_n_1(self.0, _arg) } + } + fn get_n_1(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_n_1( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_n_1(self.0) } + } + fn set_n_2(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_super_toroid_set_n_2( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_super_toroid_set_n_2(self.0, _arg) } + } + fn get_n_2(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_super_toroid_get_n_2( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_super_toroid_get_n_2(self.0) } + } +} +impl VtkParametricTorus for vtkParametricTorus { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_torus_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_torus_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_torus_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_torus_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_torus_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_torus_new(self.0) } + } + fn set_ring_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_torus_set_ring_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_torus_set_ring_radius(self.0, _arg) } + } + fn get_ring_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_torus_get_ring_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_torus_get_ring_radius(self.0) } + } + fn set_cross_section_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_parametric_torus_set_cross_section_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_parametric_torus_set_cross_section_radius(self.0, _arg) } + } + fn get_cross_section_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_parametric_torus_get_cross_section_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_parametric_torus_get_cross_section_radius(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_torus_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_torus_get_dimension(self.0) } + } +} /// computes an interpolating spline using a /// /// a Cardinal basis. @@ -11,22 +2266,13 @@ #[allow(non_camel_case_types)] pub struct vtkCardinalSpline(*mut core::ffi::c_void); impl vtkCardinalSpline { - /// Creates a new [vtkCardinalSpline] wrapped inside `vtkNew` + /// Creates a new [vtkCardinalSpline] via `vtkCardinalSpline::New()` #[doc(alias = "vtkCardinalSpline")] pub fn new() -> Self { unsafe extern "C" { fn vtkCardinalSpline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCardinalSpline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCardinalSpline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCardinalSpline_get_ptr(self.0) } + Self(unsafe { vtkCardinalSpline_new() }) } } impl std::default::Default for vtkCardinalSpline { @@ -46,12 +2292,8 @@ impl Drop for vtkCardinalSpline { #[test] fn test_vtkCardinalSpline_create_drop() { let obj = vtkCardinalSpline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCardinalSpline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// computes an interpolating spline using a Kochanek basis. /// @@ -83,22 +2325,13 @@ fn test_vtkCardinalSpline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkKochanekSpline(*mut core::ffi::c_void); impl vtkKochanekSpline { - /// Creates a new [vtkKochanekSpline] wrapped inside `vtkNew` + /// Creates a new [vtkKochanekSpline] via `vtkKochanekSpline::New()` #[doc(alias = "vtkKochanekSpline")] pub fn new() -> Self { unsafe extern "C" { fn vtkKochanekSpline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkKochanekSpline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkKochanekSpline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkKochanekSpline_get_ptr(self.0) } + Self(unsafe { vtkKochanekSpline_new() }) } } impl std::default::Default for vtkKochanekSpline { @@ -118,12 +2351,8 @@ impl Drop for vtkKochanekSpline { #[test] fn test_vtkKochanekSpline_create_drop() { let obj = vtkKochanekSpline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkKochanekSpline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a Bohemian dome. /// @@ -139,22 +2368,13 @@ fn test_vtkKochanekSpline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricBohemianDome(*mut core::ffi::c_void); impl vtkParametricBohemianDome { - /// Creates a new [vtkParametricBohemianDome] wrapped inside `vtkNew` + /// Creates a new [vtkParametricBohemianDome] via `vtkParametricBohemianDome::New()` #[doc(alias = "vtkParametricBohemianDome")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricBohemianDome_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricBohemianDome_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricBohemianDome_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricBohemianDome_get_ptr(self.0) } + Self(unsafe { vtkParametricBohemianDome_new() }) } } impl std::default::Default for vtkParametricBohemianDome { @@ -174,12 +2394,8 @@ impl Drop for vtkParametricBohemianDome { #[test] fn test_vtkParametricBohemianDome_create_drop() { let obj = vtkParametricBohemianDome::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricBohemianDome(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Bour's minimal surface. /// @@ -192,22 +2408,13 @@ fn test_vtkParametricBohemianDome_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricBour(*mut core::ffi::c_void); impl vtkParametricBour { - /// Creates a new [vtkParametricBour] wrapped inside `vtkNew` + /// Creates a new [vtkParametricBour] via `vtkParametricBour::New()` #[doc(alias = "vtkParametricBour")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricBour_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricBour_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricBour_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricBour_get_ptr(self.0) } + Self(unsafe { vtkParametricBour_new() }) } } impl std::default::Default for vtkParametricBour { @@ -227,12 +2434,8 @@ impl Drop for vtkParametricBour { #[test] fn test_vtkParametricBour_create_drop() { let obj = vtkParametricBour::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricBour(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Boy's surface. /// @@ -251,22 +2454,13 @@ fn test_vtkParametricBour_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricBoy(*mut core::ffi::c_void); impl vtkParametricBoy { - /// Creates a new [vtkParametricBoy] wrapped inside `vtkNew` + /// Creates a new [vtkParametricBoy] via `vtkParametricBoy::New()` #[doc(alias = "vtkParametricBoy")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricBoy_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricBoy_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricBoy_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricBoy_get_ptr(self.0) } + Self(unsafe { vtkParametricBoy_new() }) } } impl std::default::Default for vtkParametricBoy { @@ -286,12 +2480,8 @@ impl Drop for vtkParametricBoy { #[test] fn test_vtkParametricBoy_create_drop() { let obj = vtkParametricBoy::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricBoy(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Catalan's minimal surface. /// @@ -305,22 +2495,13 @@ fn test_vtkParametricBoy_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricCatalanMinimal(*mut core::ffi::c_void); impl vtkParametricCatalanMinimal { - /// Creates a new [vtkParametricCatalanMinimal] wrapped inside `vtkNew` + /// Creates a new [vtkParametricCatalanMinimal] via `vtkParametricCatalanMinimal::New()` #[doc(alias = "vtkParametricCatalanMinimal")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricCatalanMinimal_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricCatalanMinimal_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricCatalanMinimal_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricCatalanMinimal_get_ptr(self.0) } + Self(unsafe { vtkParametricCatalanMinimal_new() }) } } impl std::default::Default for vtkParametricCatalanMinimal { @@ -340,12 +2521,8 @@ impl Drop for vtkParametricCatalanMinimal { #[test] fn test_vtkParametricCatalanMinimal_create_drop() { let obj = vtkParametricCatalanMinimal::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricCatalanMinimal(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate conic spiral surfaces that resemble sea-shells. /// @@ -363,22 +2540,13 @@ fn test_vtkParametricCatalanMinimal_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricConicSpiral(*mut core::ffi::c_void); impl vtkParametricConicSpiral { - /// Creates a new [vtkParametricConicSpiral] wrapped inside `vtkNew` + /// Creates a new [vtkParametricConicSpiral] via `vtkParametricConicSpiral::New()` #[doc(alias = "vtkParametricConicSpiral")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricConicSpiral_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricConicSpiral_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricConicSpiral_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricConicSpiral_get_ptr(self.0) } + Self(unsafe { vtkParametricConicSpiral_new() }) } } impl std::default::Default for vtkParametricConicSpiral { @@ -398,12 +2566,8 @@ impl Drop for vtkParametricConicSpiral { #[test] fn test_vtkParametricConicSpiral_create_drop() { let obj = vtkParametricConicSpiral::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricConicSpiral(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a cross-cap. /// @@ -422,22 +2586,13 @@ fn test_vtkParametricConicSpiral_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricCrossCap(*mut core::ffi::c_void); impl vtkParametricCrossCap { - /// Creates a new [vtkParametricCrossCap] wrapped inside `vtkNew` + /// Creates a new [vtkParametricCrossCap] via `vtkParametricCrossCap::New()` #[doc(alias = "vtkParametricCrossCap")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricCrossCap_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricCrossCap_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricCrossCap_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricCrossCap_get_ptr(self.0) } + Self(unsafe { vtkParametricCrossCap_new() }) } } impl std::default::Default for vtkParametricCrossCap { @@ -457,12 +2612,8 @@ impl Drop for vtkParametricCrossCap { #[test] fn test_vtkParametricCrossCap_create_drop() { let obj = vtkParametricCrossCap::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricCrossCap(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Dini's surface. /// @@ -480,22 +2631,13 @@ fn test_vtkParametricCrossCap_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricDini(*mut core::ffi::c_void); impl vtkParametricDini { - /// Creates a new [vtkParametricDini] wrapped inside `vtkNew` + /// Creates a new [vtkParametricDini] via `vtkParametricDini::New()` #[doc(alias = "vtkParametricDini")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricDini_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricDini_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricDini_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricDini_get_ptr(self.0) } + Self(unsafe { vtkParametricDini_new() }) } } impl std::default::Default for vtkParametricDini { @@ -515,12 +2657,8 @@ impl Drop for vtkParametricDini { #[test] fn test_vtkParametricDini_create_drop() { let obj = vtkParametricDini::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricDini(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate an ellipsoid. /// @@ -542,22 +2680,13 @@ fn test_vtkParametricDini_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricEllipsoid(*mut core::ffi::c_void); impl vtkParametricEllipsoid { - /// Creates a new [vtkParametricEllipsoid] wrapped inside `vtkNew` + /// Creates a new [vtkParametricEllipsoid] via `vtkParametricEllipsoid::New()` #[doc(alias = "vtkParametricEllipsoid")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricEllipsoid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricEllipsoid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricEllipsoid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricEllipsoid_get_ptr(self.0) } + Self(unsafe { vtkParametricEllipsoid_new() }) } } impl std::default::Default for vtkParametricEllipsoid { @@ -577,12 +2706,8 @@ impl Drop for vtkParametricEllipsoid { #[test] fn test_vtkParametricEllipsoid_create_drop() { let obj = vtkParametricEllipsoid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricEllipsoid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Enneper's surface. /// @@ -601,22 +2726,13 @@ fn test_vtkParametricEllipsoid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricEnneper(*mut core::ffi::c_void); impl vtkParametricEnneper { - /// Creates a new [vtkParametricEnneper] wrapped inside `vtkNew` + /// Creates a new [vtkParametricEnneper] via `vtkParametricEnneper::New()` #[doc(alias = "vtkParametricEnneper")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricEnneper_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricEnneper_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricEnneper_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricEnneper_get_ptr(self.0) } + Self(unsafe { vtkParametricEnneper_new() }) } } impl std::default::Default for vtkParametricEnneper { @@ -636,12 +2752,8 @@ impl Drop for vtkParametricEnneper { #[test] fn test_vtkParametricEnneper_create_drop() { let obj = vtkParametricEnneper::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricEnneper(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a figure-8 Klein bottle. /// @@ -667,22 +2779,13 @@ fn test_vtkParametricEnneper_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricFigure8Klein(*mut core::ffi::c_void); impl vtkParametricFigure8Klein { - /// Creates a new [vtkParametricFigure8Klein] wrapped inside `vtkNew` + /// Creates a new [vtkParametricFigure8Klein] via `vtkParametricFigure8Klein::New()` #[doc(alias = "vtkParametricFigure8Klein")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricFigure8Klein_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricFigure8Klein_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricFigure8Klein_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricFigure8Klein_get_ptr(self.0) } + Self(unsafe { vtkParametricFigure8Klein_new() }) } } impl std::default::Default for vtkParametricFigure8Klein { @@ -702,12 +2805,8 @@ impl Drop for vtkParametricFigure8Klein { #[test] fn test_vtkParametricFigure8Klein_create_drop() { let obj = vtkParametricFigure8Klein::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricFigure8Klein(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Henneberg's minimal surface. /// @@ -720,22 +2819,13 @@ fn test_vtkParametricFigure8Klein_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricHenneberg(*mut core::ffi::c_void); impl vtkParametricHenneberg { - /// Creates a new [vtkParametricHenneberg] wrapped inside `vtkNew` + /// Creates a new [vtkParametricHenneberg] via `vtkParametricHenneberg::New()` #[doc(alias = "vtkParametricHenneberg")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricHenneberg_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricHenneberg_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricHenneberg_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricHenneberg_get_ptr(self.0) } + Self(unsafe { vtkParametricHenneberg_new() }) } } impl std::default::Default for vtkParametricHenneberg { @@ -755,12 +2845,8 @@ impl Drop for vtkParametricHenneberg { #[test] fn test_vtkParametricHenneberg_create_drop() { let obj = vtkParametricHenneberg::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricHenneberg(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generates a "classical" representation of a Klein bottle. /// @@ -786,22 +2872,13 @@ fn test_vtkParametricHenneberg_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricKlein(*mut core::ffi::c_void); impl vtkParametricKlein { - /// Creates a new [vtkParametricKlein] wrapped inside `vtkNew` + /// Creates a new [vtkParametricKlein] via `vtkParametricKlein::New()` #[doc(alias = "vtkParametricKlein")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricKlein_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricKlein_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricKlein_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricKlein_get_ptr(self.0) } + Self(unsafe { vtkParametricKlein_new() }) } } impl std::default::Default for vtkParametricKlein { @@ -821,12 +2898,8 @@ impl Drop for vtkParametricKlein { #[test] fn test_vtkParametricKlein_create_drop() { let obj = vtkParametricKlein::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricKlein(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Kuens' surface. /// @@ -840,22 +2913,13 @@ fn test_vtkParametricKlein_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricKuen(*mut core::ffi::c_void); impl vtkParametricKuen { - /// Creates a new [vtkParametricKuen] wrapped inside `vtkNew` + /// Creates a new [vtkParametricKuen] via `vtkParametricKuen::New()` #[doc(alias = "vtkParametricKuen")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricKuen_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricKuen_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricKuen_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricKuen_get_ptr(self.0) } + Self(unsafe { vtkParametricKuen_new() }) } } impl std::default::Default for vtkParametricKuen { @@ -875,12 +2939,8 @@ impl Drop for vtkParametricKuen { #[test] fn test_vtkParametricKuen_create_drop() { let obj = vtkParametricKuen::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricKuen(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a Mobius strip. /// @@ -897,22 +2957,13 @@ fn test_vtkParametricKuen_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricMobius(*mut core::ffi::c_void); impl vtkParametricMobius { - /// Creates a new [vtkParametricMobius] wrapped inside `vtkNew` + /// Creates a new [vtkParametricMobius] via `vtkParametricMobius::New()` #[doc(alias = "vtkParametricMobius")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricMobius_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricMobius_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricMobius_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricMobius_get_ptr(self.0) } + Self(unsafe { vtkParametricMobius_new() }) } } impl std::default::Default for vtkParametricMobius { @@ -932,12 +2983,8 @@ impl Drop for vtkParametricMobius { #[test] fn test_vtkParametricMobius_create_drop() { let obj = vtkParametricMobius::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricMobius(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Plucker's conoid surface. /// @@ -955,22 +3002,13 @@ fn test_vtkParametricMobius_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricPluckerConoid(*mut core::ffi::c_void); impl vtkParametricPluckerConoid { - /// Creates a new [vtkParametricPluckerConoid] wrapped inside `vtkNew` + /// Creates a new [vtkParametricPluckerConoid] via `vtkParametricPluckerConoid::New()` #[doc(alias = "vtkParametricPluckerConoid")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricPluckerConoid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricPluckerConoid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricPluckerConoid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricPluckerConoid_get_ptr(self.0) } + Self(unsafe { vtkParametricPluckerConoid_new() }) } } impl std::default::Default for vtkParametricPluckerConoid { @@ -990,12 +3028,8 @@ impl Drop for vtkParametricPluckerConoid { #[test] fn test_vtkParametricPluckerConoid_create_drop() { let obj = vtkParametricPluckerConoid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricPluckerConoid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a pseudosphere. /// @@ -1010,22 +3044,13 @@ fn test_vtkParametricPluckerConoid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricPseudosphere(*mut core::ffi::c_void); impl vtkParametricPseudosphere { - /// Creates a new [vtkParametricPseudosphere] wrapped inside `vtkNew` + /// Creates a new [vtkParametricPseudosphere] via `vtkParametricPseudosphere::New()` #[doc(alias = "vtkParametricPseudosphere")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricPseudosphere_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricPseudosphere_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricPseudosphere_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricPseudosphere_get_ptr(self.0) } + Self(unsafe { vtkParametricPseudosphere_new() }) } } impl std::default::Default for vtkParametricPseudosphere { @@ -1045,12 +3070,8 @@ impl Drop for vtkParametricPseudosphere { #[test] fn test_vtkParametricPseudosphere_create_drop() { let obj = vtkParametricPseudosphere::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricPseudosphere(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a surface covered with randomly placed hills. /// @@ -1071,22 +3092,13 @@ fn test_vtkParametricPseudosphere_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricRandomHills(*mut core::ffi::c_void); impl vtkParametricRandomHills { - /// Creates a new [vtkParametricRandomHills] wrapped inside `vtkNew` + /// Creates a new [vtkParametricRandomHills] via `vtkParametricRandomHills::New()` #[doc(alias = "vtkParametricRandomHills")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricRandomHills_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricRandomHills_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricRandomHills_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricRandomHills_get_ptr(self.0) } + Self(unsafe { vtkParametricRandomHills_new() }) } } impl std::default::Default for vtkParametricRandomHills { @@ -1106,12 +3118,8 @@ impl Drop for vtkParametricRandomHills { #[test] fn test_vtkParametricRandomHills_create_drop() { let obj = vtkParametricRandomHills::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricRandomHills(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate Steiner's Roman Surface. /// @@ -1128,22 +3136,13 @@ fn test_vtkParametricRandomHills_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricRoman(*mut core::ffi::c_void); impl vtkParametricRoman { - /// Creates a new [vtkParametricRoman] wrapped inside `vtkNew` + /// Creates a new [vtkParametricRoman] via `vtkParametricRoman::New()` #[doc(alias = "vtkParametricRoman")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricRoman_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricRoman_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricRoman_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricRoman_get_ptr(self.0) } + Self(unsafe { vtkParametricRoman_new() }) } } impl std::default::Default for vtkParametricRoman { @@ -1163,12 +3162,8 @@ impl Drop for vtkParametricRoman { #[test] fn test_vtkParametricRoman_create_drop() { let obj = vtkParametricRoman::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricRoman(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// parametric function for 1D interpolating splines /// @@ -1193,22 +3188,13 @@ fn test_vtkParametricRoman_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricSpline(*mut core::ffi::c_void); impl vtkParametricSpline { - /// Creates a new [vtkParametricSpline] wrapped inside `vtkNew` + /// Creates a new [vtkParametricSpline] via `vtkParametricSpline::New()` #[doc(alias = "vtkParametricSpline")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricSpline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricSpline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricSpline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricSpline_get_ptr(self.0) } + Self(unsafe { vtkParametricSpline_new() }) } } impl std::default::Default for vtkParametricSpline { @@ -1228,12 +3214,8 @@ impl Drop for vtkParametricSpline { #[test] fn test_vtkParametricSpline_create_drop() { let obj = vtkParametricSpline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricSpline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a superellipsoid. /// @@ -1259,22 +3241,13 @@ fn test_vtkParametricSpline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricSuperEllipsoid(*mut core::ffi::c_void); impl vtkParametricSuperEllipsoid { - /// Creates a new [vtkParametricSuperEllipsoid] wrapped inside `vtkNew` + /// Creates a new [vtkParametricSuperEllipsoid] via `vtkParametricSuperEllipsoid::New()` #[doc(alias = "vtkParametricSuperEllipsoid")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricSuperEllipsoid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricSuperEllipsoid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricSuperEllipsoid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricSuperEllipsoid_get_ptr(self.0) } + Self(unsafe { vtkParametricSuperEllipsoid_new() }) } } impl std::default::Default for vtkParametricSuperEllipsoid { @@ -1294,12 +3267,8 @@ impl Drop for vtkParametricSuperEllipsoid { #[test] fn test_vtkParametricSuperEllipsoid_create_drop() { let obj = vtkParametricSuperEllipsoid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricSuperEllipsoid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a supertoroid. /// @@ -1329,22 +3298,13 @@ fn test_vtkParametricSuperEllipsoid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricSuperToroid(*mut core::ffi::c_void); impl vtkParametricSuperToroid { - /// Creates a new [vtkParametricSuperToroid] wrapped inside `vtkNew` + /// Creates a new [vtkParametricSuperToroid] via `vtkParametricSuperToroid::New()` #[doc(alias = "vtkParametricSuperToroid")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricSuperToroid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricSuperToroid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricSuperToroid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricSuperToroid_get_ptr(self.0) } + Self(unsafe { vtkParametricSuperToroid_new() }) } } impl std::default::Default for vtkParametricSuperToroid { @@ -1364,12 +3324,8 @@ impl Drop for vtkParametricSuperToroid { #[test] fn test_vtkParametricSuperToroid_create_drop() { let obj = vtkParametricSuperToroid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricSuperToroid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generate a torus. /// @@ -1386,22 +3342,13 @@ fn test_vtkParametricSuperToroid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkParametricTorus(*mut core::ffi::c_void); impl vtkParametricTorus { - /// Creates a new [vtkParametricTorus] wrapped inside `vtkNew` + /// Creates a new [vtkParametricTorus] via `vtkParametricTorus::New()` #[doc(alias = "vtkParametricTorus")] pub fn new() -> Self { unsafe extern "C" { fn vtkParametricTorus_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkParametricTorus_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkParametricTorus_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkParametricTorus_get_ptr(self.0) } + Self(unsafe { vtkParametricTorus_new() }) } } impl std::default::Default for vtkParametricTorus { @@ -1421,10 +3368,6 @@ impl Drop for vtkParametricTorus { #[test] fn test_vtkParametricTorus_create_drop() { let obj = vtkParametricTorus::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkParametricTorus(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonCore.rs b/vtk-rs-9.1/src/vtkCommonCore.rs index 208cbee..08294de 100644 --- a/vtk-rs-9.1/src/vtkCommonCore.rs +++ b/vtk-rs-9.1/src/vtkCommonCore.rs @@ -1,3 +1,11771 @@ +pub trait VtkAOSDataArrayTemplate { + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_longlong, + tuple: *mut core::ffi::c_void, + ) -> (); + fn write_pointer( + &mut self, + valueIdx: core::ffi::c_longlong, + numValues: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + fn get_pointer(&mut self, valueIdx: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn set_array( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn data_element_changed(&mut self, p0: core::ffi::c_longlong) -> (); + fn begin(&mut self) -> *mut core::ffi::c_void; + fn end(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkAbstractArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + numValues: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn set_number_of_components(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_components_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_components_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn set_component_name(&mut self, component: core::ffi::c_longlong, name: &str) -> (); + fn get_component_name(&mut self, component: core::ffi::c_longlong) -> &str; + fn has_a_component_name(&mut self) -> bool; + fn copy_component_names(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, numTuples: core::ffi::c_longlong) -> (); + fn set_number_of_values(&mut self, numValues: core::ffi::c_longlong) -> bool; + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong; + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; + fn set_tuple( + &mut self, + dstTupleIdx: core::ffi::c_longlong, + srcTupleIdx: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + dstTupleIdx: core::ffi::c_longlong, + srcTupleIdx: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + srcTupleIdx: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn get_tuples( + &mut self, + tupleIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn has_standard_memory_layout(&mut self) -> bool; + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn reset(&mut self) -> (); + fn get_size(&mut self) -> core::ffi::c_longlong; + fn get_max_id(&mut self) -> core::ffi::c_longlong; + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn set_name(&mut self, _arg: &str) -> (); + fn get_data_type_as_string(&mut self) -> &str; + fn create_array(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_size(&mut self) -> core::ffi::c_longlong; + fn data_changed(&mut self) -> (); + fn clear_lookup(&mut self) -> (); + fn get_prominent_component_values( + &mut self, + comp: core::ffi::c_int, + values: *mut core::ffi::c_void, + uncertainty: core::ffi::c_double, + minimumProminence: core::ffi::c_double, + ) -> (); + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn has_information(&mut self) -> bool; + fn copy_information( + &mut self, + infoFrom: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> core::ffi::c_int; + fn gui_hide(&mut self) -> *mut core::ffi::c_void; + fn per_component(&mut self) -> *mut core::ffi::c_void; + fn per_finite_component(&mut self) -> *mut core::ffi::c_void; + fn modified(&mut self) -> (); + fn discrete_values(&mut self) -> *mut core::ffi::c_void; + fn discrete_value_sample_parameters(&mut self) -> *mut core::ffi::c_void; + fn get_max_discrete_values(&mut self) -> core::ffi::c_uint; + fn set_max_discrete_values(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_array_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkAnimationCue { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> (); + fn get_time_mode(&mut self) -> core::ffi::c_int; + fn set_time_mode_to_relative(&mut self) -> (); + fn set_time_mode_to_normalized(&mut self) -> (); + fn set_start_time(&mut self, _arg: core::ffi::c_double) -> (); + fn get_start_time(&mut self) -> core::ffi::c_double; + fn set_end_time(&mut self, _arg: core::ffi::c_double) -> (); + fn get_end_time(&mut self) -> core::ffi::c_double; + fn tick( + &mut self, + currenttime: core::ffi::c_double, + deltatime: core::ffi::c_double, + clocktime: core::ffi::c_double, + ) -> (); + fn initialize(&mut self) -> (); + fn finalize(&mut self) -> (); + fn get_animation_time(&mut self) -> core::ffi::c_double; + fn get_delta_time(&mut self) -> core::ffi::c_double; + fn get_clock_time(&mut self) -> core::ffi::c_double; +} +pub trait VtkArchiver { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_archive_name(&mut self, _arg: &str) -> (); + fn open_archive(&mut self) -> (); + fn close_archive(&mut self) -> (); + fn insert_into_archive(&mut self, relativePath: &str, data: &str, size: usize) -> (); + fn contains(&mut self, relativePath: &str) -> bool; +} +pub trait VtkArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn create_array( + &mut self, + StorageType: core::ffi::c_int, + ValueType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn is_dense(&mut self) -> bool; + fn resize(&mut self, i: core::ffi::c_longlong) -> (); + fn get_dimensions(&mut self) -> core::ffi::c_longlong; + fn get_size(&mut self) -> core::ffi::c_ulonglong; + fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; + fn deep_copy(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkArrayCoordinates { + fn get_dimensions(&mut self) -> core::ffi::c_longlong; + fn set_dimensions(&mut self, dimensions: core::ffi::c_longlong) -> (); + fn get_coordinate(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn set_coordinate( + &mut self, + i: core::ffi::c_longlong, + p1: &core::ffi::c_longlong, + ) -> (); +} +pub trait VtkArrayExtents { + fn get_dimensions(&mut self) -> core::ffi::c_longlong; + fn get_size(&mut self) -> core::ffi::c_ulonglong; + fn set_dimensions(&mut self, dimensions: core::ffi::c_longlong) -> (); + fn zero_based(&mut self) -> bool; +} +pub trait VtkArrayExtentsList { + fn get_count(&mut self) -> core::ffi::c_longlong; + fn set_count(&mut self, count: core::ffi::c_longlong) -> (); +} +pub trait VtkArrayIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkArrayIteratorTemplate { + fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); + fn get_array(&mut self) -> *mut core::ffi::c_void; + fn get_tuple(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong; + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; +} +pub trait VtkArrayRange { + fn get_begin(&mut self) -> core::ffi::c_longlong; + fn get_end(&mut self) -> core::ffi::c_longlong; + fn get_size(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkArraySort { + fn get_dimensions(&mut self) -> core::ffi::c_longlong; + fn set_dimensions(&mut self, dimensions: core::ffi::c_longlong) -> (); +} +pub trait VtkArrayWeights { + fn get_count(&mut self) -> core::ffi::c_longlong; + fn set_count(&mut self, count: core::ffi::c_longlong) -> (); +} +pub trait VtkBitArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn remove_tuple(&mut self, id: core::ffi::c_longlong) -> (); + fn set_component( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> (); + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> (); + fn insert_value(&mut self, id: core::ffi::c_longlong, i: core::ffi::c_int) -> (); + fn insert_next_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_longlong; + fn insert_component( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn data_changed(&mut self) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkBitArrayIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, array: *mut core::ffi::c_void) -> (); + fn get_array(&mut self) -> *mut core::ffi::c_void; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong; + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> (); +} +pub trait VtkBoxMuellerRandomSequence { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self) -> (); + fn get_uniform_sequence(&mut self) -> *mut core::ffi::c_void; + fn set_uniform_sequence(&mut self, uniformSequence: *mut core::ffi::c_void) -> (); +} +pub trait VtkBreakPoint { + fn break_(&mut self) -> (); +} +pub trait VtkBuffer { + fn get_buffer(&mut self) -> *mut core::ffi::c_void; + fn set_buffer( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + ) -> (); + fn set_malloc_function(&mut self, mallocFunction: *mut core::ffi::c_void) -> (); + fn set_realloc_function(&mut self, reallocFunction: *mut core::ffi::c_void) -> (); + fn set_free_function( + &mut self, + noFreeFunction: bool, + deleteFunction: *mut core::ffi::c_void, + ) -> (); + fn get_size(&mut self) -> core::ffi::c_longlong; + fn allocate(&mut self, size: core::ffi::c_longlong) -> bool; + fn reallocate(&mut self, newsize: core::ffi::c_longlong) -> bool; +} +pub trait VtkByteSwap { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCallbackCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_abort_flag_on_execute(&mut self, f: core::ffi::c_int) -> (); + fn get_abort_flag_on_execute(&mut self) -> core::ffi::c_int; + fn abort_flag_on_execute_on(&mut self) -> (); + fn abort_flag_on_execute_off(&mut self) -> (); +} +pub trait VtkCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn set_typed_tuple(&mut self, i: core::ffi::c_longlong, tuple: &str) -> (); + fn insert_typed_tuple(&mut self, i: core::ffi::c_longlong, tuple: &str) -> (); + fn insert_next_typed_tuple(&mut self, tuple: &str) -> core::ffi::c_longlong; + fn get_value(&mut self, id: core::ffi::c_longlong) -> &str; + fn set_value(&mut self, id: core::ffi::c_longlong, value: &str) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: &str) -> (); + fn insert_next_value(&mut self, f: &str) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> &str; + fn get_data_type_value_max(&mut self) -> &str; +} +pub trait VtkCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn insert_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); + fn remove_item(&mut self, i: core::ffi::c_int) -> (); + fn remove_all_items(&mut self) -> (); + fn is_item_present(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_number_of_items(&mut self) -> core::ffi::c_int; + fn init_traversal(&mut self) -> (); + fn get_next_item_as_object(&mut self) -> *mut core::ffi::c_void; + fn get_item_as_object(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); +} +pub trait VtkCollectionIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_collection(&mut self) -> *mut core::ffi::c_void; + fn init_traversal(&mut self) -> (); + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_object(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCommand { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn un_register(&mut self) -> (); + fn get_string_from_event_id(&mut self, event: core::ffi::c_ulong) -> &str; + fn get_event_id_from_string(&mut self, event: &str) -> core::ffi::c_ulong; + fn event_has_data(&mut self, event: core::ffi::c_ulong) -> bool; + fn set_abort_flag(&mut self, f: core::ffi::c_int) -> (); + fn get_abort_flag(&mut self) -> core::ffi::c_int; + fn abort_flag_on(&mut self) -> (); + fn abort_flag_off(&mut self) -> (); + fn set_passive_observer(&mut self, f: core::ffi::c_int) -> (); + fn get_passive_observer(&mut self) -> core::ffi::c_int; + fn passive_observer_on(&mut self) -> (); + fn passive_observer_off(&mut self) -> (); +} +pub trait VtkCommonInformationKeyManager { + fn register(&mut self, key: *mut core::ffi::c_void) -> (); +} +pub trait VtkConditionVariable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn signal(&mut self) -> (); + fn broadcast(&mut self) -> (); + fn wait(&mut self, mutex: *mut core::ffi::c_void) -> core::ffi::c_int; +} +pub trait VtkCriticalSection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkDataArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn insert_tuple( + &mut self, + dstTupleIdx: core::ffi::c_longlong, + srcTupleIdx: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + srcTupleIdx: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn get_tuple_1(&mut self, tupleIdx: core::ffi::c_longlong) -> core::ffi::c_double; + fn set_tuple( + &mut self, + dstTupleIdx: core::ffi::c_longlong, + srcTupleIdx: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn set_tuple_1( + &mut self, + tupleIdx: core::ffi::c_longlong, + value: core::ffi::c_double, + ) -> (); + fn set_tuple_2( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + ) -> (); + fn set_tuple_3( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + ) -> (); + fn set_tuple_4( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + ) -> (); + fn set_tuple_6( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + ) -> (); + fn set_tuple_9( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + val6: core::ffi::c_double, + val7: core::ffi::c_double, + val8: core::ffi::c_double, + ) -> (); + fn insert_tuple_1( + &mut self, + tupleIdx: core::ffi::c_longlong, + value: core::ffi::c_double, + ) -> (); + fn insert_tuple_2( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + ) -> (); + fn insert_tuple_3( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + ) -> (); + fn insert_tuple_4( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + ) -> (); + fn insert_tuple_6( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + ) -> (); + fn insert_tuple_9( + &mut self, + tupleIdx: core::ffi::c_longlong, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + val6: core::ffi::c_double, + val7: core::ffi::c_double, + val8: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_1(&mut self, value: core::ffi::c_double) -> (); + fn insert_next_tuple_2( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_3( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_4( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_6( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + ) -> (); + fn insert_next_tuple_9( + &mut self, + val0: core::ffi::c_double, + val1: core::ffi::c_double, + val2: core::ffi::c_double, + val3: core::ffi::c_double, + val4: core::ffi::c_double, + val5: core::ffi::c_double, + val6: core::ffi::c_double, + val7: core::ffi::c_double, + val8: core::ffi::c_double, + ) -> (); + fn remove_tuple(&mut self, tupleIdx: core::ffi::c_longlong) -> (); + fn remove_first_tuple(&mut self) -> (); + fn remove_last_tuple(&mut self) -> (); + fn get_component( + &mut self, + tupleIdx: core::ffi::c_longlong, + compIdx: core::ffi::c_int, + ) -> core::ffi::c_double; + fn set_component( + &mut self, + tupleIdx: core::ffi::c_longlong, + compIdx: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn insert_component( + &mut self, + tupleIdx: core::ffi::c_longlong, + compIdx: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_data( + &mut self, + tupleMin: core::ffi::c_longlong, + tupleMax: core::ffi::c_longlong, + compMin: core::ffi::c_int, + compMax: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> (); + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn fill_component( + &mut self, + compIdx: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn fill(&mut self, value: core::ffi::c_double) -> (); + fn copy_component( + &mut self, + dstComponent: core::ffi::c_int, + src: *mut core::ffi::c_void, + srcComponent: core::ffi::c_int, + ) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn create_default_lookup_table(&mut self) -> (); + fn set_lookup_table(&mut self, lut: *mut core::ffi::c_void) -> (); + fn get_lookup_table(&mut self) -> *mut core::ffi::c_void; + fn get_data_type_min(&mut self) -> core::ffi::c_double; + fn get_data_type_max(&mut self) -> core::ffi::c_double; + fn get_max_norm(&mut self) -> core::ffi::c_double; + fn create_data_array( + &mut self, + dataType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn component_range(&mut self) -> *mut core::ffi::c_void; + fn l_2_norm_range(&mut self) -> *mut core::ffi::c_void; + fn l_2_norm_finite_range(&mut self) -> *mut core::ffi::c_void; + fn modified(&mut self) -> (); + fn units_label(&mut self) -> *mut core::ffi::c_void; + fn copy_information( + &mut self, + infoFrom: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_array_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkDataArrayCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkDataArrayCollectionIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDataArraySelection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn enable_array(&mut self, name: &str) -> (); + fn disable_array(&mut self, name: &str) -> (); + fn array_is_enabled(&mut self, name: &str) -> core::ffi::c_int; + fn array_exists(&mut self, name: &str) -> core::ffi::c_int; + fn enable_all_arrays(&mut self) -> (); + fn disable_all_arrays(&mut self) -> (); + fn get_number_of_arrays(&mut self) -> core::ffi::c_int; + fn get_number_of_arrays_enabled(&mut self) -> core::ffi::c_int; + fn get_array_name(&mut self, index: core::ffi::c_int) -> &str; + fn get_array_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_enabled_array_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_array_setting(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; + fn set_array_setting(&mut self, name: &str, setting: core::ffi::c_int) -> (); + fn remove_all_arrays(&mut self) -> (); + fn add_array(&mut self, name: &str, state: bool) -> core::ffi::c_int; + fn remove_array_by_index(&mut self, index: core::ffi::c_int) -> (); + fn remove_array_by_name(&mut self, name: &str) -> (); + fn copy_selections(&mut self, selections: *mut core::ffi::c_void) -> (); + fn union(&mut self, other: *mut core::ffi::c_void) -> (); + fn set_unknown_array_setting(&mut self, _arg: core::ffi::c_int) -> (); + fn get_unknown_array_setting(&mut self) -> core::ffi::c_int; +} +pub trait VtkDebugLeaks { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn construct_class(&mut self, object: *mut core::ffi::c_void) -> (); + fn destruct_class(&mut self, object: *mut core::ffi::c_void) -> (); + fn print_current_leaks(&mut self) -> core::ffi::c_int; + fn get_exit_error(&mut self) -> core::ffi::c_int; + fn set_exit_error(&mut self, p0: core::ffi::c_int) -> (); + fn set_debug_leaks_observer(&mut self, observer: *mut core::ffi::c_void) -> (); + fn get_debug_leaks_observer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDebugLeaksObserver { + fn constructing_object(&mut self, p0: *mut core::ffi::c_void) -> (); + fn destructing_object(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkDenseArray { + fn is_dense(&mut self) -> bool; + fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; + fn deep_copy(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDoubleArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_double) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_double) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_double) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_double; + fn get_data_type_value_max(&mut self) -> core::ffi::c_double; +} +pub trait VtkDynamicLoader { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn lib_prefix(&mut self) -> &str; + fn lib_extension(&mut self) -> &str; + fn last_error(&mut self) -> &str; +} +pub trait VtkEventData { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn get_type(&mut self) -> core::ffi::c_int; + fn set_type(&mut self, val: core::ffi::c_int) -> (); + fn get_as_event_data_for_device(&mut self) -> *mut core::ffi::c_void; + fn get_as_event_data_device_3_d(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkEventDataDevice3D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_track_pad_position( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> (); +} +pub trait VtkEventDataForDevice { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkEventForwarderCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_target(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkFileOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn display_text(&mut self, p0: &str) -> (); + fn set_file_name(&mut self, _arg: &str) -> (); + fn set_flush(&mut self, _arg: core::ffi::c_int) -> (); + fn get_flush(&mut self) -> core::ffi::c_int; + fn flush_on(&mut self) -> (); + fn flush_off(&mut self) -> (); + fn set_append(&mut self, _arg: core::ffi::c_int) -> (); + fn get_append(&mut self) -> core::ffi::c_int; + fn append_on(&mut self) -> (); + fn append_off(&mut self) -> (); +} +pub trait VtkFloatArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_float; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_float) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_float) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_float) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_float; + fn get_data_type_value_max(&mut self) -> core::ffi::c_float; +} +pub trait VtkFloatingPointExceptions { + fn enable(&mut self) -> (); + fn disable(&mut self) -> (); +} +pub trait VtkGarbageCollector { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn collect(&mut self) -> (); + fn deferred_collection_push(&mut self) -> (); + fn deferred_collection_pop(&mut self) -> (); + fn set_global_debug_flag(&mut self, flag: bool) -> (); + fn get_global_debug_flag(&mut self) -> bool; +} +pub trait VtkGaussianRandomSequence { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_scaled_value( + &mut self, + mean: core::ffi::c_double, + standardDeviation: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_next_scaled_value( + &mut self, + mean: core::ffi::c_double, + standardDeviation: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkGenericDataArray { + fn get_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_longlong, + tuple: *mut core::ffi::c_void, + ) -> (); + fn get_pointer(&mut self, valueIdx: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn write_pointer( + &mut self, + valueIdx: core::ffi::c_longlong, + numValues: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + fn remove_tuple(&mut self, tupleIdx: core::ffi::c_longlong) -> (); + fn get_value_range(&mut self, comp: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_finite_value_range( + &mut self, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn capacity(&mut self) -> core::ffi::c_longlong; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn allocate( + &mut self, + size: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_number_of_components(&mut self, num: core::ffi::c_int) -> (); + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn initialize(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn clear_lookup(&mut self) -> (); + fn data_changed(&mut self) -> (); + fn new_iterator(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkGenericDataArrayLookupHelper { + fn set_array(&mut self, array: *mut core::ffi::c_void) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkIdList { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + strategy: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_number_of_ids(&mut self) -> core::ffi::c_longlong; + fn get_id(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn find_id_location(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn set_number_of_ids(&mut self, number: core::ffi::c_longlong) -> (); + fn set_id(&mut self, i: core::ffi::c_longlong, vtkid: core::ffi::c_longlong) -> (); + fn insert_id( + &mut self, + i: core::ffi::c_longlong, + vtkid: core::ffi::c_longlong, + ) -> (); + fn insert_next_id(&mut self, vtkid: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn insert_unique_id( + &mut self, + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn sort(&mut self) -> (); + fn fill(&mut self, value: core::ffi::c_longlong) -> (); + fn reset(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn deep_copy(&mut self, ids: *mut core::ffi::c_void) -> (); + fn delete_id(&mut self, vtkid: core::ffi::c_longlong) -> (); + fn is_id(&mut self, vtkid: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> (); +} +pub trait VtkIdListCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkIdTypeArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, + ) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value( + &mut self, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, + ) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_longlong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkIndent { + fn delete(&mut self) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn modified(&mut self) -> (); + fn clear(&mut self) -> (); + fn get_number_of_keys(&mut self) -> core::ffi::c_int; + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); + fn append(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn copy_entries( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> (); + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, key: *mut core::ffi::c_void) -> (); + fn set(&mut self, key: *mut core::ffi::c_void) -> (); + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn set_request(&mut self, request: *mut core::ffi::c_void) -> (); + fn get_request(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformationDataObjectKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationDoubleKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_double) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_double; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationDoubleVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: &str, + location: &str, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_double) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIdTypeKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_longlong) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_longlong; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationInformationKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn deep_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationInformationVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn deep_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIntegerKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_int) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIntegerPointerKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIntegerVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: &str, + location: &str, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: core::ffi::c_int) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn set_information_weak(&mut self, p0: *mut core::ffi::c_void) -> (); + fn init_traversal(&mut self) -> (); + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_key(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformationKey { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn register(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_name(&mut self) -> &str; + fn get_location(&mut self) -> &str; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn deep_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn has(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn remove(&mut self, info: *mut core::ffi::c_void) -> (); + fn report( + &mut self, + info: *mut core::ffi::c_void, + collector: *mut core::ffi::c_void, + ) -> (); + fn print(&mut self, info: *mut core::ffi::c_void) -> (); + fn need_to_execute( + &mut self, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> bool; + fn store_meta_data( + &mut self, + request: *mut core::ffi::c_void, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> (); + fn copy_default_information( + &mut self, + request: *mut core::ffi::c_void, + fromInfo: *mut core::ffi::c_void, + toInfo: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationKeyLookup { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn find(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; +} +pub trait VtkInformationKeyVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn append( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn append_unique( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn remove_item( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationObjectBaseKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: &str, + location: &str, + requiredClass: &str, + ) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: *mut core::ffi::c_void) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationObjectBaseVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: &str, + location: &str, + requiredClass: &str, + ) -> *mut core::ffi::c_void; + fn clear(&mut self, info: *mut core::ffi::c_void) -> (); + fn resize(&mut self, info: *mut core::ffi::c_void, size: core::ffi::c_int) -> (); + fn size(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> (); + fn remove( + &mut self, + info: *mut core::ffi::c_void, + val: *mut core::ffi::c_void, + ) -> (); + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + source: *mut core::ffi::c_void, + dest: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationRequestKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void) -> (); + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationStringKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: &str) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> &str; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationStringVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: &str, + location: &str, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void, value: &str) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: &str, + index: core::ffi::c_int, + ) -> (); + fn get(&mut self, info: *mut core::ffi::c_void, idx: core::ffi::c_int) -> &str; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationUnsignedLongKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set(&mut self, info: *mut core::ffi::c_void, p1: core::ffi::c_ulong) -> (); + fn get(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_ulong; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationVariantKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationVariantVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key( + &mut self, + name: &str, + location: &str, + length: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationVector { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_information_objects(&mut self) -> core::ffi::c_int; + fn set_number_of_information_objects(&mut self, n: core::ffi::c_int) -> (); + fn set_information_object( + &mut self, + index: core::ffi::c_int, + info: *mut core::ffi::c_void, + ) -> (); + fn get_information_object( + &mut self, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn append(&mut self, info: *mut core::ffi::c_void) -> (); + fn remove(&mut self, info: *mut core::ffi::c_void) -> (); + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> (); +} +pub trait VtkIntArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_int) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_int) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_int; + fn get_data_type_value_max(&mut self) -> core::ffi::c_int; +} +pub trait VtkLargeInteger { + fn cast_to_char(&mut self) -> &str; + fn cast_to_short(&mut self) -> core::ffi::c_short; + fn cast_to_int(&mut self) -> core::ffi::c_int; + fn cast_to_long(&mut self) -> core::ffi::c_long; + fn cast_to_unsigned_long(&mut self) -> core::ffi::c_ulong; + fn is_even(&mut self) -> core::ffi::c_int; + fn is_odd(&mut self) -> core::ffi::c_int; + fn get_length(&mut self) -> core::ffi::c_int; + fn get_bit(&mut self, p: core::ffi::c_uint) -> core::ffi::c_int; + fn is_zero(&mut self) -> core::ffi::c_int; + fn get_sign(&mut self) -> core::ffi::c_int; + fn truncate(&mut self, n: core::ffi::c_uint) -> (); + fn complement(&mut self) -> (); +} +pub trait VtkLogger { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn init(&mut self) -> (); + fn end_log_to_file(&mut self, path: &str) -> (); + fn set_thread_name(&mut self, name: &str) -> (); + fn remove_callback(&mut self, id: &str) -> bool; + fn is_enabled(&mut self) -> bool; + fn end_scope(&mut self, id: &str) -> (); +} +pub trait VtkLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_long; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_long) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_long) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_long) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_long; + fn get_data_type_value_max(&mut self) -> core::ffi::c_long; +} +pub trait VtkLongLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, + ) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value( + &mut self, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, + ) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_longlong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkLookupTable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_opaque(&mut self) -> core::ffi::c_int; + fn allocate( + &mut self, + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int; + fn build(&mut self) -> (); + fn force_build(&mut self) -> (); + fn build_special_colors(&mut self) -> (); + fn set_ramp(&mut self, _arg: core::ffi::c_int) -> (); + fn set_ramp_to_linear(&mut self) -> (); + fn set_ramp_to_s_curve(&mut self) -> (); + fn set_ramp_to_sqrt(&mut self) -> (); + fn get_ramp(&mut self) -> core::ffi::c_int; + fn set_scale(&mut self, scale: core::ffi::c_int) -> (); + fn set_scale_to_linear(&mut self) -> (); + fn set_scale_to_log_10(&mut self) -> (); + fn get_scale(&mut self) -> core::ffi::c_int; + fn set_table_range( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> (); + fn set_hue_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_saturation_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_value_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_alpha_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_nan_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn set_below_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn set_use_below_range_color(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_below_range_color(&mut self) -> core::ffi::c_int; + fn use_below_range_color_on(&mut self) -> (); + fn use_below_range_color_off(&mut self) -> (); + fn set_above_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); + fn set_use_above_range_color(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_above_range_color(&mut self) -> core::ffi::c_int; + fn use_above_range_color_on(&mut self) -> (); + fn use_above_range_color_off(&mut self) -> (); + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn get_index(&mut self, v: core::ffi::c_double) -> core::ffi::c_longlong; + fn set_number_of_table_values(&mut self, number: core::ffi::c_longlong) -> (); + fn get_number_of_table_values(&mut self) -> core::ffi::c_longlong; + fn set_table_value( + &mut self, + indx: core::ffi::c_longlong, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> (); + fn set_number_of_colors(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_number_of_colors_min_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_colors_max_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_colors(&mut self) -> core::ffi::c_longlong; + fn set_table(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_table(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn using_log_scale(&mut self) -> core::ffi::c_int; +} +pub trait VtkMappedDataArray { + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn data_changed(&mut self) -> (); + fn modified(&mut self) -> (); +} +pub trait VtkMath { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn pi(&mut self) -> core::ffi::c_double; + fn radians_from_degrees( + &mut self, + degrees: core::ffi::c_float, + ) -> core::ffi::c_float; + fn degrees_from_radians( + &mut self, + radians: core::ffi::c_float, + ) -> core::ffi::c_float; + fn round(&mut self, f: core::ffi::c_float) -> core::ffi::c_int; + fn floor(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn ceil(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn ceil_log_2(&mut self, x: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn is_power_of_two(&mut self, x: core::ffi::c_ulonglong) -> bool; + fn nearest_power_of_two(&mut self, x: core::ffi::c_int) -> core::ffi::c_int; + fn factorial(&mut self, N: core::ffi::c_int) -> core::ffi::c_longlong; + fn binomial( + &mut self, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_longlong; + fn random_seed(&mut self, s: core::ffi::c_int) -> (); + fn get_seed(&mut self) -> core::ffi::c_int; + fn random(&mut self) -> core::ffi::c_double; + fn gaussian(&mut self) -> core::ffi::c_double; + fn gaussian_amplitude( + &mut self, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + fn gaussian_weight( + &mut self, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + fn determinant_2_x_2( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double; + fn determinant_3_x_3( + &mut self, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double; + fn solve_linear_system_gepp_2_x_2( + &mut self, + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: &mut core::ffi::c_double, + x1: &mut core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_scalar_type_fitting_range( + &mut self, + range_min: core::ffi::c_double, + range_max: core::ffi::c_double, + scale: core::ffi::c_double, + shift: core::ffi::c_double, + ) -> core::ffi::c_int; + fn inf(&mut self) -> core::ffi::c_double; + fn neg_inf(&mut self) -> core::ffi::c_double; + fn nan(&mut self) -> core::ffi::c_double; + fn is_inf(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn is_nan(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn is_finite(&mut self, x: core::ffi::c_double) -> bool; +} +pub trait VtkMersenneTwister { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn initialize_new_sequence( + &mut self, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> core::ffi::c_uint; + fn initialize_sequence( + &mut self, + id: core::ffi::c_uint, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> (); + fn get_value(&mut self, id: core::ffi::c_uint) -> core::ffi::c_double; + fn next(&mut self, id: core::ffi::c_uint) -> (); +} +pub trait VtkMinimalStandardRandomSequence { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn set_seed(&mut self, value: core::ffi::c_int) -> (); + fn set_seed_only(&mut self, value: core::ffi::c_int) -> (); + fn get_seed(&mut self) -> core::ffi::c_int; + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self) -> (); + fn get_range_value( + &mut self, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_next_range_value( + &mut self, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; +} +pub trait VtkMultiThreader { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_threads(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads(&mut self) -> core::ffi::c_int; + fn get_global_static_maximum_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_global_maximum_number_of_threads(&mut self, val: core::ffi::c_int) -> (); + fn get_global_maximum_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_global_default_number_of_threads(&mut self, val: core::ffi::c_int) -> (); + fn get_global_default_number_of_threads(&mut self) -> core::ffi::c_int; + fn single_method_execute(&mut self) -> (); + fn multiple_method_execute(&mut self) -> (); + fn terminate_thread(&mut self, threadId: core::ffi::c_int) -> (); + fn is_thread_active(&mut self, threadId: core::ffi::c_int) -> core::ffi::c_int; +} +pub trait VtkMutexLock { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkNew { + fn reset(&mut self) -> (); + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkOStrStreamWrapper { + fn rdbuf(&mut self) -> *mut core::ffi::c_void; + fn freeze(&mut self) -> (); +} +pub trait VtkObject { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int; + fn is_a(&mut self, type_: &str) -> core::ffi::c_int; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_generations_from_base_type( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong; + fn new(&mut self) -> *mut core::ffi::c_void; + fn debug_on(&mut self) -> (); + fn debug_off(&mut self) -> (); + fn get_debug(&mut self) -> bool; + fn set_debug(&mut self, debugFlag: bool) -> (); + fn break_on_error(&mut self) -> (); + fn modified(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_global_warning_display(&mut self, val: core::ffi::c_int) -> (); + fn global_warning_display_on(&mut self) -> (); + fn global_warning_display_off(&mut self) -> (); + fn get_global_warning_display(&mut self) -> core::ffi::c_int; + fn add_observer( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong; + fn get_command(&mut self, tag: core::ffi::c_ulong) -> *mut core::ffi::c_void; + fn remove_observer(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_observers( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> (); + fn has_observer( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn remove_all_observers(&mut self) -> (); +} +pub trait VtkObjectBase { + fn get_class_name(&mut self) -> &str; + fn is_type_of(&mut self, name: &str) -> core::ffi::c_int; + fn is_a(&mut self, name: &str) -> core::ffi::c_int; + fn get_number_of_generations_from_base_type( + &mut self, + name: &str, + ) -> core::ffi::c_longlong; + fn get_number_of_generations_from_base( + &mut self, + name: &str, + ) -> core::ffi::c_longlong; + fn delete(&mut self) -> (); + fn fast_delete(&mut self) -> (); + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize_object_base(&mut self) -> (); + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn un_register(&mut self, o: *mut core::ffi::c_void) -> (); + fn get_reference_count(&mut self) -> core::ffi::c_int; + fn set_reference_count(&mut self, p0: core::ffi::c_int) -> (); + fn set_memkind_directory(&mut self, directoryname: &str) -> (); + fn get_using_memkind(&mut self) -> bool; + fn get_is_in_memkind(&mut self) -> bool; +} +pub trait VtkObjectFactory { + fn create_instance( + &mut self, + vtkclassname: &str, + isAbstract: bool, + ) -> *mut core::ffi::c_void; + fn create_all_instance( + &mut self, + vtkclassname: &str, + retList: *mut core::ffi::c_void, + ) -> (); + fn re_hash(&mut self) -> (); + fn register_factory(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register_factory(&mut self, p0: *mut core::ffi::c_void) -> (); + fn un_register_all_factories(&mut self) -> (); + fn get_registered_factories(&mut self) -> *mut core::ffi::c_void; + fn has_override_any(&mut self, className: &str) -> core::ffi::c_int; + fn get_override_information(&mut self, name: &str, p1: *mut core::ffi::c_void) -> (); + fn set_all_enable_flags(&mut self, flag: core::ffi::c_int, className: &str) -> (); + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vtk_source_version(&mut self) -> &str; + fn get_description(&mut self) -> &str; + fn get_number_of_overrides(&mut self) -> core::ffi::c_int; + fn get_class_override_name(&mut self, index: core::ffi::c_int) -> &str; + fn get_class_override_with_name(&mut self, index: core::ffi::c_int) -> &str; + fn get_enable_flag(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; + fn get_override_description(&mut self, index: core::ffi::c_int) -> &str; + fn set_enable_flag( + &mut self, + flag: core::ffi::c_int, + className: &str, + subclassName: &str, + ) -> (); + fn has_override(&mut self, className: &str) -> core::ffi::c_int; + fn disable(&mut self, className: &str) -> (); +} +pub trait VtkObjectFactoryCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, t: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkOldStyleCallbackCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> (); +} +pub trait VtkOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_instance(&mut self) -> *mut core::ffi::c_void; + fn set_instance(&mut self, instance: *mut core::ffi::c_void) -> (); + fn display_text(&mut self, p0: &str) -> (); + fn display_error_text(&mut self, p0: &str) -> (); + fn display_warning_text(&mut self, p0: &str) -> (); + fn display_generic_warning_text(&mut self, p0: &str) -> (); + fn display_debug_text(&mut self, p0: &str) -> (); + fn prompt_user_on(&mut self) -> (); + fn prompt_user_off(&mut self) -> (); + fn set_prompt_user(&mut self, _arg: bool) -> (); + fn set_use_std_error_for_all_messages(&mut self, p0: bool) -> (); + fn get_use_std_error_for_all_messages(&mut self) -> bool; + fn use_std_error_for_all_messages_on(&mut self) -> (); + fn use_std_error_for_all_messages_off(&mut self) -> (); + fn set_display_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_display_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_display_mode_max_value(&mut self) -> core::ffi::c_int; + fn get_display_mode(&mut self) -> core::ffi::c_int; + fn set_display_mode_to_default(&mut self) -> (); + fn set_display_mode_to_never(&mut self) -> (); + fn set_display_mode_to_always(&mut self) -> (); + fn set_display_mode_to_always_std_err(&mut self) -> (); +} +pub trait VtkOverrideInformation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_class_override_name(&mut self) -> &str; + fn get_class_override_with_name(&mut self) -> &str; + fn get_description(&mut self) -> &str; + fn get_object_factory(&mut self) -> *mut core::ffi::c_void; + fn set_class_override_name(&mut self, _arg: &str) -> (); + fn set_class_override_with_name(&mut self, _arg: &str) -> (); + fn set_description(&mut self, _arg: &str) -> (); +} +pub trait VtkOverrideInformationCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPoints { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> (); + fn set_data_type_to_bit(&mut self) -> (); + fn set_data_type_to_char(&mut self) -> (); + fn set_data_type_to_unsigned_char(&mut self) -> (); + fn set_data_type_to_short(&mut self) -> (); + fn set_data_type_to_unsigned_short(&mut self) -> (); + fn set_data_type_to_int(&mut self) -> (); + fn set_data_type_to_unsigned_int(&mut self) -> (); + fn set_data_type_to_long(&mut self) -> (); + fn set_data_type_to_unsigned_long(&mut self) -> (); + fn set_data_type_to_float(&mut self) -> (); + fn set_data_type_to_double(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn set_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn insert_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn insert_points( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> (); + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + outPoints: *mut core::ffi::c_void, + ) -> (); + fn compute_bounds(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn modified(&mut self) -> (); +} +pub trait VtkPoints2D { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> (); + fn set_data_type_to_bit(&mut self) -> (); + fn set_data_type_to_char(&mut self) -> (); + fn set_data_type_to_unsigned_char(&mut self) -> (); + fn set_data_type_to_short(&mut self) -> (); + fn set_data_type_to_unsigned_short(&mut self) -> (); + fn set_data_type_to_int(&mut self) -> (); + fn set_data_type_to_unsigned_int(&mut self) -> (); + fn set_data_type_to_long(&mut self) -> (); + fn set_data_type_to_unsigned_long(&mut self) -> (); + fn set_data_type_to_float(&mut self) -> (); + fn set_data_type_to_double(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn set_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> (); + fn insert_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> (); + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn remove_point(&mut self, id: core::ffi::c_longlong) -> (); + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> (); + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + fp: *mut core::ffi::c_void, + ) -> (); + fn compute_bounds(&mut self) -> (); +} +pub trait VtkPriorityQueue { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate(&mut self, sz: core::ffi::c_longlong, ext: core::ffi::c_longlong) -> (); + fn insert(&mut self, priority: core::ffi::c_double, id: core::ffi::c_longlong) -> (); + fn pop( + &mut self, + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn peek( + &mut self, + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn delete_id(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double; + fn get_priority(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double; + fn get_number_of_items(&mut self) -> core::ffi::c_longlong; + fn reset(&mut self) -> (); +} +pub trait VtkRandomPool { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_sequence(&mut self, seq: *mut core::ffi::c_void) -> (); + fn get_sequence(&mut self) -> *mut core::ffi::c_void; + fn set_size(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_size_min_value(&mut self) -> core::ffi::c_longlong; + fn get_size_max_value(&mut self) -> core::ffi::c_longlong; + fn get_size(&mut self) -> core::ffi::c_longlong; + fn set_number_of_components(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_number_of_components_min_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_components_max_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_components(&mut self) -> core::ffi::c_longlong; + fn get_total_size(&mut self) -> core::ffi::c_longlong; + fn get_value(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_double; + fn populate_data_array( + &mut self, + da: *mut core::ffi::c_void, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ) -> (); + fn set_chunk_size(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_chunk_size_min_value(&mut self) -> core::ffi::c_longlong; + fn get_chunk_size_max_value(&mut self) -> core::ffi::c_longlong; + fn get_chunk_size(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkRandomSequence { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, seed: core::ffi::c_uint) -> (); + fn get_value(&mut self) -> core::ffi::c_double; + fn next(&mut self) -> (); + fn get_next_value(&mut self) -> core::ffi::c_double; +} +pub trait VtkReferenceCount { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkSMPThreadLocal { + fn size(&mut self) -> usize; +} +pub trait VtkSMPThreadLocalObject { + fn local(&mut self) -> *mut core::ffi::c_void; + fn size(&mut self) -> usize; +} +pub trait VtkSMPTools { + fn get_backend(&mut self) -> &str; + fn set_backend(&mut self, backend: &str) -> bool; + fn initialize(&mut self, numThreads: core::ffi::c_int) -> (); + fn get_estimated_number_of_threads(&mut self) -> core::ffi::c_int; + fn set_nested_parallelism(&mut self, isNested: bool) -> (); + fn get_nested_parallelism(&mut self) -> bool; + fn is_parallel_scope(&mut self) -> bool; +} +pub trait VtkSOADataArrayTemplate { + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_longlong, + tuple: *mut core::ffi::c_void, + ) -> (); + fn set_array( + &mut self, + comp: core::ffi::c_int, + array: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + updateMaxId: bool, + save: bool, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_component_array_pointer( + &mut self, + comp: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_number_of_components(&mut self, numComps: core::ffi::c_int) -> (); +} +pub trait VtkScalarsToColors { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn is_opaque(&mut self) -> core::ffi::c_int; + fn build(&mut self) -> (); + fn set_range(&mut self, min: core::ffi::c_double, max: core::ffi::c_double) -> (); + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double; + fn get_luminance(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn set_alpha(&mut self, alpha: core::ffi::c_double) -> (); + fn get_alpha(&mut self) -> core::ffi::c_double; + fn map_scalars( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_vector_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_mode(&mut self) -> core::ffi::c_int; + fn set_vector_mode_to_magnitude(&mut self) -> (); + fn set_vector_mode_to_component(&mut self) -> (); + fn set_vector_mode_to_rgb_colors(&mut self) -> (); + fn set_vector_component(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_component(&mut self) -> core::ffi::c_int; + fn set_vector_size(&mut self, _arg: core::ffi::c_int) -> (); + fn get_vector_size(&mut self) -> core::ffi::c_int; + fn deep_copy(&mut self, o: *mut core::ffi::c_void) -> (); + fn using_log_scale(&mut self) -> core::ffi::c_int; + fn get_number_of_available_colors(&mut self) -> core::ffi::c_longlong; + fn set_annotations( + &mut self, + values: *mut core::ffi::c_void, + annotations: *mut core::ffi::c_void, + ) -> (); + fn get_annotated_values(&mut self) -> *mut core::ffi::c_void; + fn get_annotations(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_annotated_values(&mut self) -> core::ffi::c_longlong; + fn reset_annotations(&mut self) -> (); + fn set_indexed_lookup(&mut self, _arg: core::ffi::c_int) -> (); + fn get_indexed_lookup(&mut self) -> core::ffi::c_int; + fn indexed_lookup_on(&mut self) -> (); + fn indexed_lookup_off(&mut self) -> (); +} +pub trait VtkShortArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_short; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_short) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_short) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_short) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_short; + fn get_data_type_value_max(&mut self) -> core::ffi::c_short; +} +pub trait VtkSignedCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_schar; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_schar) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_schar) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_schar) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_schar; + fn get_data_type_value_max(&mut self) -> core::ffi::c_schar; +} +pub trait VtkSimpleConditionVariable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn signal(&mut self) -> (); + fn broadcast(&mut self) -> (); +} +pub trait VtkSimpleCriticalSection { + fn init(&mut self) -> (); + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkSimpleMutexLock { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn lock(&mut self) -> (); + fn unlock(&mut self) -> (); +} +pub trait VtkSmartPointer { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; + fn take_reference(&mut self, t: *mut core::ffi::c_void) -> (); +} +pub trait VtkSmartPointerBase { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn report(&mut self, collector: *mut core::ffi::c_void, desc: &str) -> (); +} +pub trait VtkSortDataArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn sort(&mut self, keys: *mut core::ffi::c_void) -> (); + fn sort_array_by_component( + &mut self, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + ) -> (); +} +pub trait VtkSparseArray { + fn is_dense(&mut self) -> bool; + fn get_non_null_size(&mut self) -> core::ffi::c_ulonglong; + fn deep_copy(&mut self) -> *mut core::ffi::c_void; + fn clear(&mut self) -> (); + fn reserve_storage(&mut self, value_count: core::ffi::c_ulonglong) -> (); + fn set_extents_from_contents(&mut self) -> (); + fn validate(&mut self) -> bool; +} +pub trait VtkStringArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; + fn get_number_of_element_components(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn write_pointer( + &mut self, + id: core::ffi::c_longlong, + number: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + fn get_pointer(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn set_array( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_size(&mut self) -> core::ffi::c_longlong; + fn data_changed(&mut self) -> (); + fn data_element_changed(&mut self, id: core::ffi::c_longlong) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkStringOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn display_text(&mut self, p0: &str) -> (); +} +pub trait VtkTestDataArray { + fn get_typed_tuple( + &mut self, + tupleIdx: core::ffi::c_longlong, + tuple: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkTimePointUtility { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn date_to_time_point( + &mut self, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn time_to_time_point( + &mut self, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn date_time_to_time_point( + &mut self, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + sec: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + fn get_date( + &mut self, + time: core::ffi::c_ulonglong, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + ) -> (); + fn get_time( + &mut self, + time: core::ffi::c_ulonglong, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, + ) -> (); + fn get_date_time( + &mut self, + time: core::ffi::c_ulonglong, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, + ) -> (); + fn get_year(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_month(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_day(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_hour(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_minute(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_second(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn get_millisecond(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int; + fn time_point_to_iso_8601( + &mut self, + p0: core::ffi::c_ulonglong, + format: core::ffi::c_int, + ) -> &str; +} +pub trait VtkTimeStamp { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn modified(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkTypeFloat32Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeFloat64Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt16Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt32Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt64Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeInt8Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt16Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt32Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt64Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypeUInt8Array { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkTypedArray {} +pub trait VtkTypedDataArray { + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_typed_tuple( + &mut self, + idx: core::ffi::c_longlong, + t: *mut core::ffi::c_void, + ) -> (); + fn allocate( + &mut self, + size: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; +} +pub trait VtkUnicodeString { + fn is_utf_8(&mut self, p0: &str) -> bool; + fn utf_8_str(&mut self) -> &str; + fn empty(&mut self) -> bool; + fn push_back(&mut self, p0: core::ffi::c_uint) -> (); + fn clear(&mut self) -> (); +} +pub trait VtkUnicodeStringArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn data_changed(&mut self) -> (); + fn clear_lookup(&mut self) -> (); + fn insert_next_utf_8_value(&mut self, p0: &str) -> (); + fn set_utf_8_value(&mut self, i: core::ffi::c_longlong, p1: &str) -> (); + fn get_utf_8_value(&mut self, i: core::ffi::c_longlong) -> &str; +} +pub trait VtkUnsignedCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_uchar) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_uchar) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar; + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkUnsignedIntArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_uint; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_uint) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_uint) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_uint) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_uint; + fn get_data_type_value_max(&mut self) -> core::ffi::c_uint; +} +pub trait VtkUnsignedLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ulong; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_ulong) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_ulong) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_ulong) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkUnsignedLongLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ulonglong; + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_ulonglong, + ) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value( + &mut self, + id: core::ffi::c_longlong, + f: core::ffi::c_ulonglong, + ) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_ulonglong) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulonglong; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulonglong; +} +pub trait VtkUnsignedShortArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ushort; + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_ushort) -> (); + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool; + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_ushort) -> (); + fn insert_next_value(&mut self, f: core::ffi::c_ushort) -> core::ffi::c_longlong; + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_data_type_value_min(&mut self) -> core::ffi::c_ushort; + fn get_data_type_value_max(&mut self) -> core::ffi::c_ushort; +} +pub trait VtkVariant { + fn is_valid(&mut self) -> bool; + fn is_string(&mut self) -> bool; + fn is_unicode_string(&mut self) -> bool; + fn is_numeric(&mut self) -> bool; + fn is_float(&mut self) -> bool; + fn is_double(&mut self) -> bool; + fn is_char(&mut self) -> bool; + fn is_unsigned_char(&mut self) -> bool; + fn is_signed_char(&mut self) -> bool; + fn is_short(&mut self) -> bool; + fn is_unsigned_short(&mut self) -> bool; + fn is_int(&mut self) -> bool; + fn is_unsigned_int(&mut self) -> bool; + fn is_long(&mut self) -> bool; + fn is_unsigned_long(&mut self) -> bool; + fn is__int_64(&mut self) -> bool; + fn is_unsigned__int_64(&mut self) -> bool; + fn is_long_long(&mut self) -> bool; + fn is_unsigned_long_long(&mut self) -> bool; + fn is_vtk_object(&mut self) -> bool; + fn is_array(&mut self) -> bool; + fn get_type(&mut self) -> core::ffi::c_uint; + fn get_type_as_string(&mut self) -> &str; + fn to_vtk_object(&mut self) -> *mut core::ffi::c_void; + fn to_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkVariantArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn get_element_component_size(&mut self) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn squeeze(&mut self) -> (); + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn is_numeric(&mut self) -> core::ffi::c_int; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_pointer(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn set_array( + &mut self, + arr: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> (); + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> (); + fn get_number_of_values(&mut self) -> core::ffi::c_longlong; + fn data_changed(&mut self) -> (); + fn data_element_changed(&mut self, id: core::ffi::c_longlong) -> (); + fn clear_lookup(&mut self) -> (); +} +pub trait VtkVersion { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vtk_version(&mut self) -> &str; + fn get_vtk_version_full(&mut self) -> &str; + fn get_vtk_major_version(&mut self) -> core::ffi::c_int; + fn get_vtk_minor_version(&mut self) -> core::ffi::c_int; + fn get_vtk_build_version(&mut self) -> core::ffi::c_int; + fn get_vtk_source_version(&mut self) -> &str; +} +pub trait VtkVoidArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_data_type(&mut self) -> core::ffi::c_int; + fn get_data_type_size(&mut self) -> core::ffi::c_int; + fn set_number_of_pointers(&mut self, number: core::ffi::c_longlong) -> (); + fn get_number_of_pointers(&mut self) -> core::ffi::c_longlong; + fn reset(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn deep_copy(&mut self, va: *mut core::ffi::c_void) -> (); +} +pub trait VtkWeakPointer { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWeakPointerBase { + fn get_pointer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWeakReference { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set(&mut self, object: *mut core::ffi::c_void) -> (); + fn get(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_window_info(&mut self, p0: &str) -> (); + fn set_parent_info(&mut self, p0: &str) -> (); + fn set_position(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); + fn set_size(&mut self, width: core::ffi::c_int, height: core::ffi::c_int) -> (); + fn get_mapped(&mut self) -> core::ffi::c_int; + fn get_show_window(&mut self) -> bool; + fn set_show_window(&mut self, _arg: bool) -> (); + fn show_window_on(&mut self) -> (); + fn show_window_off(&mut self) -> (); + fn set_use_off_screen_buffers(&mut self, _arg: bool) -> (); + fn get_use_off_screen_buffers(&mut self) -> bool; + fn use_off_screen_buffers_on(&mut self) -> (); + fn use_off_screen_buffers_off(&mut self) -> (); + fn set_erase(&mut self, _arg: core::ffi::c_int) -> (); + fn get_erase(&mut self) -> core::ffi::c_int; + fn erase_on(&mut self) -> (); + fn erase_off(&mut self) -> (); + fn set_double_buffer(&mut self, _arg: core::ffi::c_int) -> (); + fn get_double_buffer(&mut self) -> core::ffi::c_int; + fn double_buffer_on(&mut self) -> (); + fn double_buffer_off(&mut self) -> (); + fn set_window_name(&mut self, _arg: &str) -> (); + fn set_icon(&mut self, p0: *mut core::ffi::c_void) -> (); + fn render(&mut self) -> (); + fn release_graphics_resources(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_dpi(&mut self) -> core::ffi::c_int; + fn set_dpi(&mut self, _arg: core::ffi::c_int) -> (); + fn get_dpi_min_value(&mut self) -> core::ffi::c_int; + fn get_dpi_max_value(&mut self) -> core::ffi::c_int; + fn detect_dpi(&mut self) -> bool; + fn set_off_screen_rendering(&mut self, val: core::ffi::c_int) -> (); + fn off_screen_rendering_on(&mut self) -> (); + fn off_screen_rendering_off(&mut self) -> (); + fn get_off_screen_rendering(&mut self) -> core::ffi::c_int; + fn make_current(&mut self) -> (); + fn release_current(&mut self) -> (); + fn set_tile_scale(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); + fn set_tile_viewport( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> (); +} +pub trait VtkXMLFileOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn display_text(&mut self, p0: &str) -> (); + fn display_tag(&mut self, p0: &str) -> (); +} +impl VtkAnimationCue for vtkAnimationCue { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_cue_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_cue_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_cue_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_cue_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_cue_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_cue_new(self.0) } + } + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_time_mode( + sself: *mut core::ffi::c_void, + mode: core::ffi::c_int, + ); + } + unsafe { vtk_animation_cue_set_time_mode(self.0, mode) } + } + fn get_time_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_cue_get_time_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_cue_get_time_mode(self.0) } + } + fn set_time_mode_to_relative(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_time_mode_to_relative( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_animation_cue_set_time_mode_to_relative(self.0) } + } + fn set_time_mode_to_normalized(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_time_mode_to_normalized( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_animation_cue_set_time_mode_to_normalized(self.0) } + } + fn set_start_time(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_start_time( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_animation_cue_set_start_time(self.0, _arg) } + } + fn get_start_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_start_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_start_time(self.0) } + } + fn set_end_time(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_animation_cue_set_end_time( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_animation_cue_set_end_time(self.0, _arg) } + } + fn get_end_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_end_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_end_time(self.0) } + } + fn tick( + &mut self, + currenttime: core::ffi::c_double, + deltatime: core::ffi::c_double, + clocktime: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_animation_cue_tick( + sself: *mut core::ffi::c_void, + currenttime: core::ffi::c_double, + deltatime: core::ffi::c_double, + clocktime: core::ffi::c_double, + ); + } + unsafe { vtk_animation_cue_tick(self.0, currenttime, deltatime, clocktime) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_cue_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_cue_initialize(self.0) } + } + fn finalize(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_cue_finalize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_cue_finalize(self.0) } + } + fn get_animation_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_animation_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_animation_time(self.0) } + } + fn get_delta_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_delta_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_delta_time(self.0) } + } + fn get_clock_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_cue_get_clock_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_cue_get_clock_time(self.0) } + } +} +impl VtkArchiver for vtkArchiver { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_archiver_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_archiver_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_archiver_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_archiver_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_archiver_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_archiver_new_instance(self.0) } + } + fn set_archive_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_archiver_set_archive_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_archiver_set_archive_name(self.0, c__arg.as_ptr()) } + } + fn open_archive(&mut self) -> () { + unsafe extern "C" { + fn vtk_archiver_open_archive(sself: *mut core::ffi::c_void); + } + unsafe { vtk_archiver_open_archive(self.0) } + } + fn close_archive(&mut self) -> () { + unsafe extern "C" { + fn vtk_archiver_close_archive(sself: *mut core::ffi::c_void); + } + unsafe { vtk_archiver_close_archive(self.0) } + } + fn insert_into_archive( + &mut self, + relativePath: &str, + data: &str, + size: usize, + ) -> () { + let c_relativePath = std::ffi::CString::new(relativePath) + .expect("CString::new failed"); + let c_data = std::ffi::CString::new(data).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_archiver_insert_into_archive( + sself: *mut core::ffi::c_void, + relativePath: *const core::ffi::c_char, + data: *const core::ffi::c_char, + size: usize, + ); + } + unsafe { + vtk_archiver_insert_into_archive( + self.0, + c_relativePath.as_ptr(), + c_data.as_ptr(), + size, + ) + } + } + fn contains(&mut self, relativePath: &str) -> bool { + let c_relativePath = std::ffi::CString::new(relativePath) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_archiver_contains( + sself: *mut core::ffi::c_void, + relativePath: *const core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_archiver_contains(self.0, c_relativePath.as_ptr()) } + } +} +impl VtkBitArray for vtkBitArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_bit_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_initialize(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_get_data_type_size(self.0) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ); + } + unsafe { vtk_bit_array_set_number_of_tuples(self.0, number) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_bit_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_bit_array_set_number_of_values(self.0, number) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_insert_tuple(self.0, i, j, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_bit_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_bit_array_insert_next_tuple(self.0, j, source) } + } + fn remove_tuple(&mut self, id: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_bit_array_remove_tuple( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_bit_array_remove_tuple(self.0, id) } + } + fn set_component( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_component( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, + ); + } + unsafe { vtk_bit_array_set_component(self.0, i, j, c) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_bit_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_squeeze(self.0) } + } + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_resize( + sself: *mut core::ffi::c_void, + numTuples: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_resize(self.0, numTuples) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_int, + ); + } + unsafe { vtk_bit_array_set_value(self.0, id, value) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + i: core::ffi::c_int, + ); + } + unsafe { vtk_bit_array_insert_value(self.0, id, i) } + } + fn insert_next_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_bit_array_insert_next_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_bit_array_insert_next_value(self.0, i) } + } + fn insert_component( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_bit_array_insert_component( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_int, + c: core::ffi::c_double, + ); + } + unsafe { vtk_bit_array_insert_component(self.0, i, j, c) } + } + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bit_array_deep_copy( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_deep_copy(self.0, da) } + } + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bit_array_set_array_free_function( + sself: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_set_array_free_function(self.0, callback) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_new_iterator(self.0) } + } + fn data_changed(&mut self) -> () { + unsafe extern "C" { + fn vtk_bit_array_data_changed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_data_changed(self.0) } + } + fn clear_lookup(&mut self) -> () { + unsafe extern "C" { + fn vtk_bit_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bit_array_clear_lookup(self.0) } + } +} +impl VtkBitArrayIterator for vtkBitArrayIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_iterator_new_instance(self.0) } + } + fn initialize(&mut self, array: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bit_array_iterator_initialize( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bit_array_iterator_initialize(self.0, array) } + } + fn get_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bit_array_iterator_get_array(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_value(self.0, id) } + } + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_number_of_tuples( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_bit_array_iterator_get_number_of_tuples(self.0) } + } + fn get_number_of_values(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_number_of_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_bit_array_iterator_get_number_of_values(self.0) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_number_of_components(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bit_array_iterator_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bit_array_iterator_get_data_type_size(self.0) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_bit_array_iterator_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_int, + ); + } + unsafe { vtk_bit_array_iterator_set_value(self.0, id, value) } + } +} +impl VtkBoxMuellerRandomSequence for vtkBoxMuellerRandomSequence { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_mueller_random_sequence_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_mueller_random_sequence_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_mueller_random_sequence_new_instance(self.0) } + } + fn initialize(&mut self, seed: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_initialize( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_uint, + ); + } + unsafe { vtk_box_mueller_random_sequence_initialize(self.0, seed) } + } + fn get_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_get_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_box_mueller_random_sequence_get_value(self.0) } + } + fn next(&mut self) -> () { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_next(sself: *mut core::ffi::c_void); + } + unsafe { vtk_box_mueller_random_sequence_next(self.0) } + } + fn get_uniform_sequence(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_get_uniform_sequence( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_mueller_random_sequence_get_uniform_sequence(self.0) } + } + fn set_uniform_sequence(&mut self, uniformSequence: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_box_mueller_random_sequence_set_uniform_sequence( + sself: *mut core::ffi::c_void, + uniformSequence: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_box_mueller_random_sequence_set_uniform_sequence(self.0, uniformSequence) + } + } +} +impl VtkByteSwap for vtkByteSwap { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_byte_swap_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_byte_swap_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_byte_swap_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_byte_swap_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_byte_swap_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_byte_swap_new_instance(self.0) } + } +} +impl VtkCallbackCommand for vtkCallbackCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_callback_command_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_callback_command_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_callback_command_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_callback_command_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_callback_command_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_callback_command_new(self.0) } + } + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_callback_command_set_callback( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_callback_command_set_callback(self.0, f) } + } + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_callback_command_set_client_data_delete_callback( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_callback_command_set_client_data_delete_callback(self.0, f) } + } + fn set_abort_flag_on_execute(&mut self, f: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_callback_command_set_abort_flag_on_execute( + sself: *mut core::ffi::c_void, + f: core::ffi::c_int, + ); + } + unsafe { vtk_callback_command_set_abort_flag_on_execute(self.0, f) } + } + fn get_abort_flag_on_execute(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_callback_command_get_abort_flag_on_execute( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_callback_command_get_abort_flag_on_execute(self.0) } + } + fn abort_flag_on_execute_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_callback_command_abort_flag_on_execute_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_callback_command_abort_flag_on_execute_on(self.0) } + } + fn abort_flag_on_execute_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_callback_command_abort_flag_on_execute_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_callback_command_abort_flag_on_execute_off(self.0) } + } +} +impl VtkCharArray for vtkCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_char_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_char_array_get_data_type(self.0) } + } + fn set_typed_tuple(&mut self, i: core::ffi::c_longlong, tuple: &str) -> () { + let c_tuple = std::ffi::CString::new(tuple).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_char_array_set_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + tuple: *const core::ffi::c_char, + ); + } + unsafe { vtk_char_array_set_typed_tuple(self.0, i, c_tuple.as_ptr()) } + } + fn insert_typed_tuple(&mut self, i: core::ffi::c_longlong, tuple: &str) -> () { + let c_tuple = std::ffi::CString::new(tuple).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_char_array_insert_typed_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + tuple: *const core::ffi::c_char, + ); + } + unsafe { vtk_char_array_insert_typed_tuple(self.0, i, c_tuple.as_ptr()) } + } + fn insert_next_typed_tuple(&mut self, tuple: &str) -> core::ffi::c_longlong { + let c_tuple = std::ffi::CString::new(tuple).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_char_array_insert_next_typed_tuple( + sself: *mut core::ffi::c_void, + tuple: *const core::ffi::c_char, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_char_array_insert_next_typed_tuple(self.0, c_tuple.as_ptr()) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> &str { + unsafe extern "C" { + fn vtk_char_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_char_array_get_value(self.0, id) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: &str) -> () { + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_char_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: *const core::ffi::c_char, + ); + } + unsafe { vtk_char_array_set_value(self.0, id, c_value.as_ptr()) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_char_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_char_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: &str) -> () { + let c_f = std::ffi::CString::new(f).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_char_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: *const core::ffi::c_char, + ); + } + unsafe { vtk_char_array_insert_value(self.0, id, c_f.as_ptr()) } + } + fn insert_next_value(&mut self, f: &str) -> core::ffi::c_longlong { + let c_f = std::ffi::CString::new(f).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_char_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: *const core::ffi::c_char, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_char_array_insert_next_value(self.0, c_f.as_ptr()) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_char_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_char_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> &str { + unsafe extern "C" { + fn vtk_char_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_char_array_get_data_type_value_min(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_data_type_value_max(&mut self) -> &str { + unsafe extern "C" { + fn vtk_char_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_char_array_get_data_type_value_max(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +impl VtkCollection for vtkCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_add_item(self.0, p0) } + } + fn insert_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_insert_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_insert_item(self.0, i, p1) } + } + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_replace_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_replace_item(self.0, i, p1) } + } + fn remove_item(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_collection_remove_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_collection_remove_item(self.0, i) } + } + fn remove_all_items(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_remove_all_items(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_remove_all_items(self.0) } + } + fn is_item_present(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_collection_is_item_present( + sself: *mut core::ffi::c_void, + a: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_collection_is_item_present(self.0, a) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_collection_get_number_of_items(self.0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_init_traversal(self.0) } + } + fn get_next_item_as_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_get_next_item_as_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_get_next_item_as_object(self.0) } + } + fn get_item_as_object(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_get_item_as_object( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_get_item_as_object(self.0, i) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_new_iterator(self.0) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_register(self.0, o) } + } +} +impl VtkCollectionIterator for vtkCollectionIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_new(self.0) } + } + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_set_collection( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_collection_iterator_set_collection(self.0, p0) } + } + fn get_collection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_get_collection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_get_collection(self.0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_init_traversal(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_go_to_first_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_collection_iterator_go_to_next_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_collection_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_collection_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_collection_iterator_is_done_with_traversal(self.0) } + } + fn get_current_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_collection_iterator_get_current_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_collection_iterator_get_current_object(self.0) } + } +} +impl VtkCriticalSection for vtkCriticalSection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_critical_section_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_critical_section_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_critical_section_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_critical_section_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_critical_section_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_critical_section_new_instance(self.0) } + } + fn lock(&mut self) -> () { + unsafe extern "C" { + fn vtk_critical_section_lock(sself: *mut core::ffi::c_void); + } + unsafe { vtk_critical_section_lock(self.0) } + } + fn unlock(&mut self) -> () { + unsafe extern "C" { + fn vtk_critical_section_unlock(sself: *mut core::ffi::c_void); + } + unsafe { vtk_critical_section_unlock(self.0) } + } +} +impl VtkDataArrayCollection for vtkDataArrayCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_get_next_item(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_get_item(self.0, i) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_collection_get_number_of_items(self.0) } + } +} +impl VtkDataArrayCollectionIterator for vtkDataArrayCollectionIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_iterator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_iterator_new(self.0) } + } + fn set_collection(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_set_collection( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_collection_iterator_set_collection(self.0, p0) } + } + fn get_data_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_collection_iterator_get_data_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_collection_iterator_get_data_array(self.0) } + } +} +impl VtkDataArraySelection for vtkDataArraySelection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_selection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_selection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_selection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_selection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_array_selection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_array_selection_new(self.0) } + } + fn enable_array(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_enable_array( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_data_array_selection_enable_array(self.0, c_name.as_ptr()) } + } + fn disable_array(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_disable_array( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_data_array_selection_disable_array(self.0, c_name.as_ptr()) } + } + fn array_is_enabled(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_array_is_enabled( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_array_is_enabled(self.0, c_name.as_ptr()) } + } + fn array_exists(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_array_exists( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_array_exists(self.0, c_name.as_ptr()) } + } + fn enable_all_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_enable_all_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_array_selection_enable_all_arrays(self.0) } + } + fn disable_all_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_disable_all_arrays( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_selection_disable_all_arrays(self.0) } + } + fn get_number_of_arrays(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_number_of_arrays( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_number_of_arrays(self.0) } + } + fn get_number_of_arrays_enabled(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_number_of_arrays_enabled( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_number_of_arrays_enabled(self.0) } + } + fn get_array_name(&mut self, index: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_data_array_selection_get_array_name( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_data_array_selection_get_array_name(self.0, index) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_array_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_get_array_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_array_index(self.0, c_name.as_ptr()) } + } + fn get_enabled_array_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_get_enabled_array_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_array_selection_get_enabled_array_index(self.0, c_name.as_ptr()) + } + } + fn get_array_setting(&mut self, index: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_array_setting( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_array_setting(self.0, index) } + } + fn set_array_setting(&mut self, name: &str, setting: core::ffi::c_int) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_set_array_setting( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + setting: core::ffi::c_int, + ); + } + unsafe { + vtk_data_array_selection_set_array_setting(self.0, c_name.as_ptr(), setting) + } + } + fn remove_all_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_remove_all_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_array_selection_remove_all_arrays(self.0) } + } + fn add_array(&mut self, name: &str, state: bool) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_add_array( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + state: bool, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_add_array(self.0, c_name.as_ptr(), state) } + } + fn remove_array_by_index(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_remove_array_by_index( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_data_array_selection_remove_array_by_index(self.0, index) } + } + fn remove_array_by_name(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_array_selection_remove_array_by_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_data_array_selection_remove_array_by_name(self.0, c_name.as_ptr()) } + } + fn copy_selections(&mut self, selections: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_copy_selections( + sself: *mut core::ffi::c_void, + selections: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_selection_copy_selections(self.0, selections) } + } + fn union(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_union( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_array_selection_union(self.0, other) } + } + fn set_unknown_array_setting(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_array_selection_set_unknown_array_setting( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_data_array_selection_set_unknown_array_setting(self.0, _arg) } + } + fn get_unknown_array_setting(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_array_selection_get_unknown_array_setting( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_array_selection_get_unknown_array_setting(self.0) } + } +} +impl VtkDebugLeaks for vtkDebugLeaks { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_debug_leaks_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_debug_leaks_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_debug_leaks_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_debug_leaks_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_debug_leaks_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_debug_leaks_new_instance(self.0) } + } + fn construct_class(&mut self, object: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_construct_class( + sself: *mut core::ffi::c_void, + object: *mut core::ffi::c_void, + ); + } + unsafe { vtk_debug_leaks_construct_class(self.0, object) } + } + fn destruct_class(&mut self, object: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_destruct_class( + sself: *mut core::ffi::c_void, + object: *mut core::ffi::c_void, + ); + } + unsafe { vtk_debug_leaks_destruct_class(self.0, object) } + } + fn print_current_leaks(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_debug_leaks_print_current_leaks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_debug_leaks_print_current_leaks(self.0) } + } + fn get_exit_error(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_debug_leaks_get_exit_error( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_debug_leaks_get_exit_error(self.0) } + } + fn set_exit_error(&mut self, p0: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_set_exit_error( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ); + } + unsafe { vtk_debug_leaks_set_exit_error(self.0, p0) } + } + fn set_debug_leaks_observer(&mut self, observer: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_debug_leaks_set_debug_leaks_observer( + sself: *mut core::ffi::c_void, + observer: *mut core::ffi::c_void, + ); + } + unsafe { vtk_debug_leaks_set_debug_leaks_observer(self.0, observer) } + } + fn get_debug_leaks_observer(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_debug_leaks_get_debug_leaks_observer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_debug_leaks_get_debug_leaks_observer(self.0) } + } +} +impl VtkDoubleArray for vtkDoubleArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_double_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_double_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_double; + } + unsafe { vtk_double_array_get_value(self.0, id) } + } + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_double_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_double, + ); + } + unsafe { vtk_double_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_double_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_double_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_double_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_double, + ); + } + unsafe { vtk_double_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_double) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_double_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_double_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_double_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_double_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_double_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_double_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_double_array_get_data_type_value_max(self.0) } + } +} +impl VtkDynamicLoader for vtkDynamicLoader { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_dynamic_loader_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_dynamic_loader_new_instance(self.0) } + } + fn lib_prefix(&mut self) -> &str { + unsafe extern "C" { + fn vtk_dynamic_loader_lib_prefix( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_dynamic_loader_lib_prefix(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn lib_extension(&mut self) -> &str { + unsafe extern "C" { + fn vtk_dynamic_loader_lib_extension( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_dynamic_loader_lib_extension(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn last_error(&mut self) -> &str { + unsafe extern "C" { + fn vtk_dynamic_loader_last_error( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_dynamic_loader_last_error(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +impl VtkEventDataDevice3D for vtkEventDataDevice3D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_device_3_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_device_3_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_device_3_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_device_3_d_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_device_3_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_device_3_d_new(self.0) } + } + fn set_track_pad_position( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_event_data_device_3_d_set_track_pad_position( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_event_data_device_3_d_set_track_pad_position(self.0, x, y) } + } +} +impl VtkEventDataForDevice for vtkEventDataForDevice { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_data_for_device_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_data_for_device_new(self.0) } + } +} +impl VtkEventForwarderCommand for vtkEventForwarderCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_forwarder_command_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_forwarder_command_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_forwarder_command_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_forwarder_command_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_event_forwarder_command_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_event_forwarder_command_new(self.0) } + } + fn set_target(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_event_forwarder_command_set_target( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_event_forwarder_command_set_target(self.0, obj) } + } +} +impl VtkFileOutputWindow for vtkFileOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_file_output_window_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_file_output_window_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_file_output_window_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_file_output_window_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_file_output_window_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_file_output_window_new(self.0) } + } + fn display_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_file_output_window_display_text( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_file_output_window_display_text(self.0, c_p0.as_ptr()) } + } + fn set_file_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_file_output_window_set_file_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_file_output_window_set_file_name(self.0, c__arg.as_ptr()) } + } + fn set_flush(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_file_output_window_set_flush( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_file_output_window_set_flush(self.0, _arg) } + } + fn get_flush(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_file_output_window_get_flush( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_file_output_window_get_flush(self.0) } + } + fn flush_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_file_output_window_flush_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_file_output_window_flush_on(self.0) } + } + fn flush_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_file_output_window_flush_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_file_output_window_flush_off(self.0) } + } + fn set_append(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_file_output_window_set_append( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_file_output_window_set_append(self.0, _arg) } + } + fn get_append(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_file_output_window_get_append( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_file_output_window_get_append(self.0) } + } + fn append_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_file_output_window_append_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_file_output_window_append_on(self.0) } + } + fn append_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_file_output_window_append_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_file_output_window_append_off(self.0) } + } +} +impl VtkFloatArray for vtkFloatArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_float_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_float_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_float; + } + unsafe { vtk_float_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_float_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_float, + ); + } + unsafe { vtk_float_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_float_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_float_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_float) -> () { + unsafe extern "C" { + fn vtk_float_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_float, + ); + } + unsafe { vtk_float_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_float) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_float_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_float, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_float_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_float_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_float_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_float; + } + unsafe { vtk_float_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_float_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_float; + } + unsafe { vtk_float_array_get_data_type_value_max(self.0) } + } +} +impl VtkGarbageCollector for vtkGarbageCollector { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_garbage_collector_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_garbage_collector_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_garbage_collector_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_garbage_collector_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_garbage_collector_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_garbage_collector_new(self.0) } + } + fn collect(&mut self) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_collect(sself: *mut core::ffi::c_void); + } + unsafe { vtk_garbage_collector_collect(self.0) } + } + fn deferred_collection_push(&mut self) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_deferred_collection_push( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_garbage_collector_deferred_collection_push(self.0) } + } + fn deferred_collection_pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_deferred_collection_pop( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_garbage_collector_deferred_collection_pop(self.0) } + } + fn set_global_debug_flag(&mut self, flag: bool) -> () { + unsafe extern "C" { + fn vtk_garbage_collector_set_global_debug_flag( + sself: *mut core::ffi::c_void, + flag: bool, + ); + } + unsafe { vtk_garbage_collector_set_global_debug_flag(self.0, flag) } + } + fn get_global_debug_flag(&mut self) -> bool { + unsafe extern "C" { + fn vtk_garbage_collector_get_global_debug_flag( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_garbage_collector_get_global_debug_flag(self.0) } + } +} +impl VtkIdList for vtkIdList { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_id_list_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_id_list_initialize(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + strategy: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_id_list_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + strategy: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_id_list_allocate(self.0, sz, strategy) } + } + fn get_number_of_ids(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_list_get_number_of_ids( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_list_get_number_of_ids(self.0) } + } + fn get_id(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_list_get_id( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_list_get_id(self.0, i) } + } + fn find_id_location(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_list_find_id_location( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_list_find_id_location(self.0, id) } + } + fn set_number_of_ids(&mut self, number: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_id_list_set_number_of_ids( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ); + } + unsafe { vtk_id_list_set_number_of_ids(self.0, number) } + } + fn set_id(&mut self, i: core::ffi::c_longlong, vtkid: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_id_list_set_id( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + vtkid: core::ffi::c_longlong, + ); + } + unsafe { vtk_id_list_set_id(self.0, i, vtkid) } + } + fn insert_id( + &mut self, + i: core::ffi::c_longlong, + vtkid: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_id_list_insert_id( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + vtkid: core::ffi::c_longlong, + ); + } + unsafe { vtk_id_list_insert_id(self.0, i, vtkid) } + } + fn insert_next_id(&mut self, vtkid: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_list_insert_next_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_list_insert_next_id(self.0, vtkid) } + } + fn insert_unique_id( + &mut self, + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_list_insert_unique_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_list_insert_unique_id(self.0, vtkid) } + } + fn sort(&mut self) -> () { + unsafe extern "C" { + fn vtk_id_list_sort(sself: *mut core::ffi::c_void); + } + unsafe { vtk_id_list_sort(self.0) } + } + fn fill(&mut self, value: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_id_list_fill( + sself: *mut core::ffi::c_void, + value: core::ffi::c_longlong, + ); + } + unsafe { vtk_id_list_fill(self.0, value) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_id_list_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_id_list_reset(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_id_list_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_id_list_squeeze(self.0) } + } + fn deep_copy(&mut self, ids: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_id_list_deep_copy( + sself: *mut core::ffi::c_void, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_id_list_deep_copy(self.0, ids) } + } + fn delete_id(&mut self, vtkid: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_id_list_delete_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_longlong, + ); + } + unsafe { vtk_id_list_delete_id(self.0, vtkid) } + } + fn is_id(&mut self, vtkid: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_list_is_id( + sself: *mut core::ffi::c_void, + vtkid: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_list_is_id(self.0, vtkid) } + } + fn intersect_with(&mut self, otherIds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_id_list_intersect_with( + sself: *mut core::ffi::c_void, + otherIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_id_list_intersect_with(self.0, otherIds) } + } +} +impl VtkIdListCollection for vtkIdListCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_id_list_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_id_list_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_get_next_item(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_list_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_list_collection_get_item(self.0, i) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_id_list_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_id_list_collection_get_number_of_items(self.0) } + } +} +impl VtkIdTypeArray for vtkIdTypeArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_id_type_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_id_type_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_type_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_type_array_get_value(self.0, id) } + } + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_id_type_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, + ); + } + unsafe { vtk_id_type_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_id_type_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_id_type_array_set_number_of_values(self.0, number) } + } + fn insert_value( + &mut self, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_id_type_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, + ); + } + unsafe { vtk_id_type_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_type_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_type_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_id_type_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_id_type_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_type_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_type_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_id_type_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_id_type_array_get_data_type_value_max(self.0) } + } +} +impl VtkInformation for vtkInformation { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_new_instance(self.0) } + } + fn modified(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_modified(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_modified(self.0) } + } + fn clear(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_clear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_clear(self.0) } + } + fn get_number_of_keys(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_get_number_of_keys( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_get_number_of_keys(self.0) } + } + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_copy( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy(self.0, from, deep) } + } + fn append(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_append( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_append(self.0, from, deep) } + } + fn copy_entry( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entry( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entry(self.0, from, key, deep) } + } + fn copy_entries( + &mut self, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_information_copy_entries( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_copy_entries(self.0, from, key, deep) } + } + fn has(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_has( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_has(self.0, key) } + } + fn remove(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_remove( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_remove(self.0, key) } + } + fn set(&mut self, key: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_set( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_set(self.0, key) } + } + fn get(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_get( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_get(self.0, key) } + } + fn length(&mut self, key: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_length( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_length(self.0, key) } + } + fn append_unique( + &mut self, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_append_unique( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_append_unique(self.0, key, value) } + } + fn get_key(&mut self, key: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_key( + sself: *mut core::ffi::c_void, + key: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_key(self.0, key) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_register(self.0, o) } + } + fn set_request(&mut self, request: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_set_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_set_request(self.0, request) } + } + fn get_request(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_get_request( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_get_request(self.0) } + } +} +impl VtkInformationIterator for vtkInformationIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_new_instance(self.0) } + } + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_iterator_set_information( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_iterator_set_information(self.0, p0) } + } + fn get_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_get_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_get_information(self.0) } + } + fn set_information_weak(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_iterator_set_information_weak( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_iterator_set_information_weak(self.0, p0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_iterator_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_iterator_init_traversal(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_iterator_go_to_first_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_information_iterator_go_to_next_item(sself: *mut core::ffi::c_void); + } + unsafe { vtk_information_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_iterator_is_done_with_traversal(self.0) } + } + fn get_current_key(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_iterator_get_current_key( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_iterator_get_current_key(self.0) } + } +} +impl VtkInformationKeyLookup for vtkInformationKeyLookup { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_key_lookup_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_key_lookup_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_key_lookup_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_key_lookup_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_key_lookup_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_key_lookup_new_instance(self.0) } + } + fn find(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_location = std::ffi::CString::new(location).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_information_key_lookup_find( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + location: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_information_key_lookup_find(self.0, c_name.as_ptr(), c_location.as_ptr()) + } + } +} +impl VtkInformationVector for vtkInformationVector { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_vector_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_vector_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_vector_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_vector_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_vector_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_vector_new_instance(self.0) } + } + fn get_number_of_information_objects(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_information_vector_get_number_of_information_objects( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_information_vector_get_number_of_information_objects(self.0) } + } + fn set_number_of_information_objects(&mut self, n: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_vector_set_number_of_information_objects( + sself: *mut core::ffi::c_void, + n: core::ffi::c_int, + ); + } + unsafe { vtk_information_vector_set_number_of_information_objects(self.0, n) } + } + fn set_information_object( + &mut self, + index: core::ffi::c_int, + info: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_information_vector_set_information_object( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_vector_set_information_object(self.0, index, info) } + } + fn get_information_object( + &mut self, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_information_vector_get_information_object( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_information_vector_get_information_object(self.0, index) } + } + fn append(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_vector_append( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_vector_append(self.0, info) } + } + fn remove(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_vector_remove( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_vector_remove(self.0, info) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_information_vector_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_information_vector_register(self.0, o) } + } + fn copy(&mut self, from: *mut core::ffi::c_void, deep: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_information_vector_copy( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + deep: core::ffi::c_int, + ); + } + unsafe { vtk_information_vector_copy(self.0, from, deep) } + } +} +impl VtkIntArray for vtkIntArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_int_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_int_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_int_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_int_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_int_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_int_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_int, + ); + } + unsafe { vtk_int_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_int) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_int_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_int_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_int_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_int_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_int_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_int_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_int_array_get_data_type_value_max(self.0) } + } +} +impl VtkLongArray for vtkLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_long_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_long_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_long; + } + unsafe { vtk_long_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_long) -> () { + unsafe extern "C" { + fn vtk_long_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_long, + ); + } + unsafe { vtk_long_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_long_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_long_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_long) -> () { + unsafe extern "C" { + fn vtk_long_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_long, + ); + } + unsafe { vtk_long_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_long) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_long_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_long, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_long_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_long; + } + unsafe { vtk_long_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_long { + unsafe extern "C" { + fn vtk_long_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_long; + } + unsafe { vtk_long_array_get_data_type_value_max(self.0) } + } +} +impl VtkLongLongArray for vtkLongLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_long_long_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_long_long_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_long_long_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_long_long_array_get_value(self.0, id) } + } + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_long_long_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_longlong, + ); + } + unsafe { vtk_long_long_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_long_long_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_long_long_array_set_number_of_values(self.0, number) } + } + fn insert_value( + &mut self, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_long_long_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_longlong, + ); + } + unsafe { vtk_long_long_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_long_long_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_long_long_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_long_long_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_long_long_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_long_long_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_long_long_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_long_long_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_long_long_array_get_data_type_value_max(self.0) } + } +} +impl VtkLookupTable for vtkLookupTable { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lookup_table_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lookup_table_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lookup_table_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_new_instance(self.0) } + } + fn is_opaque(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_is_opaque( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_is_opaque(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_int, + ext: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_allocate(self.0, sz, ext) } + } + fn build(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_build(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_build(self.0) } + } + fn force_build(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_force_build(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_force_build(self.0) } + } + fn build_special_colors(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_build_special_colors(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_build_special_colors(self.0) } + } + fn set_ramp(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_ramp( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_lookup_table_set_ramp(self.0, _arg) } + } + fn set_ramp_to_linear(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_ramp_to_linear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_ramp_to_linear(self.0) } + } + fn set_ramp_to_s_curve(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_ramp_to_s_curve(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_ramp_to_s_curve(self.0) } + } + fn set_ramp_to_sqrt(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_ramp_to_sqrt(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_ramp_to_sqrt(self.0) } + } + fn get_ramp(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_get_ramp( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_get_ramp(self.0) } + } + fn set_scale(&mut self, scale: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_scale( + sself: *mut core::ffi::c_void, + scale: core::ffi::c_int, + ); + } + unsafe { vtk_lookup_table_set_scale(self.0, scale) } + } + fn set_scale_to_linear(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_scale_to_linear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_scale_to_linear(self.0) } + } + fn set_scale_to_log_10(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_scale_to_log_10(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_set_scale_to_log_10(self.0) } + } + fn get_scale(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_get_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_get_scale(self.0) } + } + fn set_table_range( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_table_range( + sself: *mut core::ffi::c_void, + min: core::ffi::c_double, + max: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_table_range(self.0, min, max) } + } + fn set_hue_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_hue_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_hue_range(self.0, _arg1, _arg2) } + } + fn set_saturation_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_saturation_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_saturation_range(self.0, _arg1, _arg2) } + } + fn set_value_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_value_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_value_range(self.0, _arg1, _arg2) } + } + fn set_alpha_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_alpha_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_alpha_range(self.0, _arg1, _arg2) } + } + fn set_nan_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_nan_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_nan_color(self.0, _arg1, _arg2, _arg3, _arg4) } + } + fn set_below_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_below_range_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { + vtk_lookup_table_set_below_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + } + } + fn set_use_below_range_color(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_use_below_range_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_lookup_table_set_use_below_range_color(self.0, _arg) } + } + fn get_use_below_range_color(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_get_use_below_range_color( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_get_use_below_range_color(self.0) } + } + fn use_below_range_color_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_below_range_color_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_use_below_range_color_on(self.0) } + } + fn use_below_range_color_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_below_range_color_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_use_below_range_color_off(self.0) } + } + fn set_above_range_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_above_range_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + ); + } + unsafe { + vtk_lookup_table_set_above_range_color(self.0, _arg1, _arg2, _arg3, _arg4) + } + } + fn set_use_above_range_color(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_use_above_range_color( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_lookup_table_set_use_above_range_color(self.0, _arg) } + } + fn get_use_above_range_color(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_get_use_above_range_color( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_get_use_above_range_color(self.0) } + } + fn use_above_range_color_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_above_range_color_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_use_above_range_color_on(self.0) } + } + fn use_above_range_color_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_lookup_table_use_above_range_color_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_lookup_table_use_above_range_color_off(self.0) } + } + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_lookup_table_get_opacity( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_lookup_table_get_opacity(self.0, v) } + } + fn get_index(&mut self, v: core::ffi::c_double) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_lookup_table_get_index( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_lookup_table_get_index(self.0, v) } + } + fn set_number_of_table_values(&mut self, number: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_number_of_table_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ); + } + unsafe { vtk_lookup_table_set_number_of_table_values(self.0, number) } + } + fn get_number_of_table_values(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_lookup_table_get_number_of_table_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_lookup_table_get_number_of_table_values(self.0) } + } + fn set_table_value( + &mut self, + indx: core::ffi::c_longlong, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_table_value( + sself: *mut core::ffi::c_void, + indx: core::ffi::c_longlong, + r: core::ffi::c_double, + g: core::ffi::c_double, + b: core::ffi::c_double, + a: core::ffi::c_double, + ); + } + unsafe { vtk_lookup_table_set_table_value(self.0, indx, r, g, b, a) } + } + fn set_number_of_colors(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_number_of_colors( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_lookup_table_set_number_of_colors(self.0, _arg) } + } + fn get_number_of_colors_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_lookup_table_get_number_of_colors_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_lookup_table_get_number_of_colors_min_value(self.0) } + } + fn get_number_of_colors_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_lookup_table_get_number_of_colors_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_lookup_table_get_number_of_colors_max_value(self.0) } + } + fn get_number_of_colors(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_lookup_table_get_number_of_colors( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_lookup_table_get_number_of_colors(self.0) } + } + fn set_table(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_lookup_table_set_table( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_lookup_table_set_table(self.0, p0) } + } + fn get_table(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lookup_table_get_table( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lookup_table_get_table(self.0) } + } + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_lookup_table_deep_copy( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_lookup_table_deep_copy(self.0, obj) } + } + fn using_log_scale(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lookup_table_using_log_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lookup_table_using_log_scale(self.0) } + } +} +impl VtkMath for vtkMath { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_math_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_math_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_math_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_math_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_math_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_math_new_instance(self.0) } + } + fn pi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_pi(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_pi(self.0) } + } + fn radians_from_degrees( + &mut self, + degrees: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_radians_from_degrees( + sself: *mut core::ffi::c_void, + degrees: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_radians_from_degrees(self.0, degrees) } + } + fn degrees_from_radians( + &mut self, + radians: core::ffi::c_float, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_math_degrees_from_radians( + sself: *mut core::ffi::c_void, + radians: core::ffi::c_float, + ) -> core::ffi::c_float; + } + unsafe { vtk_math_degrees_from_radians(self.0, radians) } + } + fn round(&mut self, f: core::ffi::c_float) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_round( + sself: *mut core::ffi::c_void, + f: core::ffi::c_float, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_round(self.0, f) } + } + fn floor(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_floor( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_floor(self.0, x) } + } + fn ceil(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_ceil( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_ceil(self.0, x) } + } + fn ceil_log_2(&mut self, x: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_ceil_log_2( + sself: *mut core::ffi::c_void, + x: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_ceil_log_2(self.0, x) } + } + fn is_power_of_two(&mut self, x: core::ffi::c_ulonglong) -> bool { + unsafe extern "C" { + fn vtk_math_is_power_of_two( + sself: *mut core::ffi::c_void, + x: core::ffi::c_ulonglong, + ) -> bool; + } + unsafe { vtk_math_is_power_of_two(self.0, x) } + } + fn nearest_power_of_two(&mut self, x: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_nearest_power_of_two( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_nearest_power_of_two(self.0, x) } + } + fn factorial(&mut self, N: core::ffi::c_int) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_math_factorial( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_math_factorial(self.0, N) } + } + fn binomial( + &mut self, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_math_binomial( + sself: *mut core::ffi::c_void, + m: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_math_binomial(self.0, m, n) } + } + fn random_seed(&mut self, s: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_math_random_seed(sself: *mut core::ffi::c_void, s: core::ffi::c_int); + } + unsafe { vtk_math_random_seed(self.0, s) } + } + fn get_seed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_get_seed(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_math_get_seed(self.0) } + } + fn random(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_random(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_random(self.0) } + } + fn gaussian(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian(self.0) } + } + fn gaussian_amplitude( + &mut self, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian_amplitude( + sself: *mut core::ffi::c_void, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian_amplitude(self.0, variance, distanceFromMean) } + } + fn gaussian_weight( + &mut self, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_gaussian_weight( + sself: *mut core::ffi::c_void, + variance: core::ffi::c_double, + distanceFromMean: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_gaussian_weight(self.0, variance, distanceFromMean) } + } + fn determinant_2_x_2( + &mut self, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_determinant_2_x_2( + sself: *mut core::ffi::c_void, + a: core::ffi::c_double, + b: core::ffi::c_double, + c: core::ffi::c_double, + d: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_determinant_2_x_2(self.0, a, b, c, d) } + } + fn determinant_3_x_3( + &mut self, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_determinant_3_x_3( + sself: *mut core::ffi::c_void, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + b1: core::ffi::c_double, + b2: core::ffi::c_double, + b3: core::ffi::c_double, + c1: core::ffi::c_double, + c2: core::ffi::c_double, + c3: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_math_determinant_3_x_3(self.0, a1, a2, a3, b1, b2, b3, c1, c2, c3) } + } + fn solve_linear_system_gepp_2_x_2( + &mut self, + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: &mut core::ffi::c_double, + x1: &mut core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_solve_linear_system_gepp_2_x_2( + sself: *mut core::ffi::c_void, + a00: core::ffi::c_double, + a01: core::ffi::c_double, + a10: core::ffi::c_double, + a11: core::ffi::c_double, + b0: core::ffi::c_double, + b1: core::ffi::c_double, + x0: &mut core::ffi::c_double, + x1: &mut core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_math_solve_linear_system_gepp_2_x_2( + self.0, + a00, + a01, + a10, + a11, + b0, + b1, + x0, + x1, + ) + } + } + fn get_scalar_type_fitting_range( + &mut self, + range_min: core::ffi::c_double, + range_max: core::ffi::c_double, + scale: core::ffi::c_double, + shift: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_get_scalar_type_fitting_range( + sself: *mut core::ffi::c_void, + range_min: core::ffi::c_double, + range_max: core::ffi::c_double, + scale: core::ffi::c_double, + shift: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_math_get_scalar_type_fitting_range( + self.0, + range_min, + range_max, + scale, + shift, + ) + } + } + fn inf(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_inf(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_inf(self.0) } + } + fn neg_inf(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_neg_inf(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_neg_inf(self.0) } + } + fn nan(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_math_nan(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_math_nan(self.0) } + } + fn is_inf(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_is_inf( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_is_inf(self.0, x) } + } + fn is_nan(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_math_is_nan( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_math_is_nan(self.0, x) } + } + fn is_finite(&mut self, x: core::ffi::c_double) -> bool { + unsafe extern "C" { + fn vtk_math_is_finite( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_math_is_finite(self.0, x) } + } +} +impl VtkMersenneTwister for vtkMersenneTwister { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mersenne_twister_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mersenne_twister_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mersenne_twister_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mersenne_twister_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mersenne_twister_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mersenne_twister_new_instance(self.0) } + } + fn initialize(&mut self, seed: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_mersenne_twister_initialize( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_uint, + ); + } + unsafe { vtk_mersenne_twister_initialize(self.0, seed) } + } + fn initialize_new_sequence( + &mut self, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_mersenne_twister_initialize_new_sequence( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> core::ffi::c_uint; + } + unsafe { vtk_mersenne_twister_initialize_new_sequence(self.0, seed, p) } + } + fn initialize_sequence( + &mut self, + id: core::ffi::c_uint, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_mersenne_twister_initialize_sequence( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uint, + seed: core::ffi::c_uint, + p: core::ffi::c_int, + ); + } + unsafe { vtk_mersenne_twister_initialize_sequence(self.0, id, seed, p) } + } + fn get_value(&mut self, id: core::ffi::c_uint) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_mersenne_twister_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uint, + ) -> core::ffi::c_double; + } + unsafe { vtk_mersenne_twister_get_value(self.0, id) } + } + fn next(&mut self, id: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_mersenne_twister_next( + sself: *mut core::ffi::c_void, + id: core::ffi::c_uint, + ); + } + unsafe { vtk_mersenne_twister_next(self.0, id) } + } +} +impl VtkMinimalStandardRandomSequence for vtkMinimalStandardRandomSequence { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_minimal_standard_random_sequence_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_minimal_standard_random_sequence_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_minimal_standard_random_sequence_new_instance(self.0) } + } + fn initialize(&mut self, seed: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_initialize( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_uint, + ); + } + unsafe { vtk_minimal_standard_random_sequence_initialize(self.0, seed) } + } + fn set_seed(&mut self, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_set_seed( + sself: *mut core::ffi::c_void, + value: core::ffi::c_int, + ); + } + unsafe { vtk_minimal_standard_random_sequence_set_seed(self.0, value) } + } + fn set_seed_only(&mut self, value: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_set_seed_only( + sself: *mut core::ffi::c_void, + value: core::ffi::c_int, + ); + } + unsafe { vtk_minimal_standard_random_sequence_set_seed_only(self.0, value) } + } + fn get_seed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_get_seed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_minimal_standard_random_sequence_get_seed(self.0) } + } + fn get_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_get_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_minimal_standard_random_sequence_get_value(self.0) } + } + fn next(&mut self) -> () { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_next(sself: *mut core::ffi::c_void); + } + unsafe { vtk_minimal_standard_random_sequence_next(self.0) } + } + fn get_range_value( + &mut self, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_get_range_value( + sself: *mut core::ffi::c_void, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_minimal_standard_random_sequence_get_range_value( + self.0, + rangeMin, + rangeMax, + ) + } + } + fn get_next_range_value( + &mut self, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_minimal_standard_random_sequence_get_next_range_value( + sself: *mut core::ffi::c_void, + rangeMin: core::ffi::c_double, + rangeMax: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { + vtk_minimal_standard_random_sequence_get_next_range_value( + self.0, + rangeMin, + rangeMax, + ) + } + } +} +impl VtkMultiThreader for vtkMultiThreader { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_threader_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_threader_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_threader_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_threader_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_threader_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_threader_new_instance(self.0) } + } + fn set_number_of_threads(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_multi_threader_set_number_of_threads( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_multi_threader_set_number_of_threads(self.0, _arg) } + } + fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_number_of_threads_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_number_of_threads_min_value(self.0) } + } + fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_number_of_threads_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_number_of_threads_max_value(self.0) } + } + fn get_number_of_threads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_number_of_threads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_number_of_threads(self.0) } + } + fn get_global_static_maximum_number_of_threads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_global_static_maximum_number_of_threads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_global_static_maximum_number_of_threads(self.0) } + } + fn set_global_maximum_number_of_threads(&mut self, val: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_multi_threader_set_global_maximum_number_of_threads( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ); + } + unsafe { vtk_multi_threader_set_global_maximum_number_of_threads(self.0, val) } + } + fn get_global_maximum_number_of_threads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_global_maximum_number_of_threads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_global_maximum_number_of_threads(self.0) } + } + fn set_global_default_number_of_threads(&mut self, val: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_multi_threader_set_global_default_number_of_threads( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ); + } + unsafe { vtk_multi_threader_set_global_default_number_of_threads(self.0, val) } + } + fn get_global_default_number_of_threads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_get_global_default_number_of_threads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_get_global_default_number_of_threads(self.0) } + } + fn single_method_execute(&mut self) -> () { + unsafe extern "C" { + fn vtk_multi_threader_single_method_execute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_multi_threader_single_method_execute(self.0) } + } + fn multiple_method_execute(&mut self) -> () { + unsafe extern "C" { + fn vtk_multi_threader_multiple_method_execute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_multi_threader_multiple_method_execute(self.0) } + } + fn terminate_thread(&mut self, threadId: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_multi_threader_terminate_thread( + sself: *mut core::ffi::c_void, + threadId: core::ffi::c_int, + ); + } + unsafe { vtk_multi_threader_terminate_thread(self.0, threadId) } + } + fn is_thread_active(&mut self, threadId: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_threader_is_thread_active( + sself: *mut core::ffi::c_void, + threadId: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_threader_is_thread_active(self.0, threadId) } + } +} +impl VtkObject for vtkObject { + fn is_type_of(&mut self, type_: &str) -> core::ffi::c_int { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_object_is_type_of( + sself: *mut core::ffi::c_void, + type_: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_is_type_of(self.0, c_type.as_ptr()) } + } + fn is_a(&mut self, type_: &str) -> core::ffi::c_int { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_object_is_a( + sself: *mut core::ffi::c_void, + type_: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_is_a(self.0, c_type.as_ptr()) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_new_instance(self.0) } + } + fn get_number_of_generations_from_base_type( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_object_get_number_of_generations_from_base_type( + sself: *mut core::ffi::c_void, + type_: *const core::ffi::c_char, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_object_get_number_of_generations_from_base_type(self.0, c_type.as_ptr()) + } + } + fn get_number_of_generations_from_base( + &mut self, + type_: &str, + ) -> core::ffi::c_longlong { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_object_get_number_of_generations_from_base( + sself: *mut core::ffi::c_void, + type_: *const core::ffi::c_char, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_object_get_number_of_generations_from_base(self.0, c_type.as_ptr()) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_new(self.0) } + } + fn debug_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_debug_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_debug_on(self.0) } + } + fn debug_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_debug_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_debug_off(self.0) } + } + fn get_debug(&mut self) -> bool { + unsafe extern "C" { + fn vtk_object_get_debug(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_object_get_debug(self.0) } + } + fn set_debug(&mut self, debugFlag: bool) -> () { + unsafe extern "C" { + fn vtk_object_set_debug(sself: *mut core::ffi::c_void, debugFlag: bool); + } + unsafe { vtk_object_set_debug(self.0, debugFlag) } + } + fn break_on_error(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_break_on_error(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_break_on_error(self.0) } + } + fn modified(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_modified(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_modified(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_object_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_object_get_m_time(self.0) } + } + fn set_global_warning_display(&mut self, val: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_object_set_global_warning_display( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ); + } + unsafe { vtk_object_set_global_warning_display(self.0, val) } + } + fn global_warning_display_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_global_warning_display_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_global_warning_display_on(self.0) } + } + fn global_warning_display_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_global_warning_display_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_global_warning_display_off(self.0) } + } + fn get_global_warning_display(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_get_global_warning_display( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_get_global_warning_display(self.0) } + } + fn add_observer( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_object_add_observer( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + priority: core::ffi::c_float, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_object_add_observer(self.0, event, p1, priority) } + } + fn get_command(&mut self, tag: core::ffi::c_ulong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_get_command( + sself: *mut core::ffi::c_void, + tag: core::ffi::c_ulong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_get_command(self.0, tag) } + } + fn remove_observer(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_object_remove_observer( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_object_remove_observer(self.0, p0) } + } + fn remove_observers( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_object_remove_observers( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_object_remove_observers(self.0, event, p1) } + } + fn has_observer( + &mut self, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_object_has_observer( + sself: *mut core::ffi::c_void, + event: core::ffi::c_ulong, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_object_has_observer(self.0, event, p1) } + } + fn remove_all_observers(&mut self) -> () { + unsafe extern "C" { + fn vtk_object_remove_all_observers(sself: *mut core::ffi::c_void); + } + unsafe { vtk_object_remove_all_observers(self.0) } + } +} +impl VtkObjectFactoryCollection for vtkObjectFactoryCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_new(self.0) } + } + fn add_item(&mut self, t: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_object_factory_collection_add_item( + sself: *mut core::ffi::c_void, + t: *mut core::ffi::c_void, + ); + } + unsafe { vtk_object_factory_collection_add_item(self.0, t) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_object_factory_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_object_factory_collection_get_next_item(self.0) } + } +} +impl VtkOldStyleCallbackCommand for vtkOldStyleCallbackCommand { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_old_style_callback_command_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_old_style_callback_command_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_old_style_callback_command_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_old_style_callback_command_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_old_style_callback_command_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_old_style_callback_command_new(self.0) } + } + fn set_callback(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_old_style_callback_command_set_callback( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_old_style_callback_command_set_callback(self.0, f) } + } + fn set_client_data_delete_callback(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_old_style_callback_command_set_client_data_delete_callback( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_old_style_callback_command_set_client_data_delete_callback(self.0, f) + } + } +} +impl VtkOutputWindow for vtkOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_output_window_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_output_window_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_output_window_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_output_window_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_output_window_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_output_window_new(self.0) } + } + fn get_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_output_window_get_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_output_window_get_instance(self.0) } + } + fn set_instance(&mut self, instance: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_output_window_set_instance( + sself: *mut core::ffi::c_void, + instance: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_instance(self.0, instance) } + } + fn display_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_output_window_display_text( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_text(self.0, c_p0.as_ptr()) } + } + fn display_error_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_output_window_display_error_text( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_error_text(self.0, c_p0.as_ptr()) } + } + fn display_warning_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_output_window_display_warning_text( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_warning_text(self.0, c_p0.as_ptr()) } + } + fn display_generic_warning_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_output_window_display_generic_warning_text( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_generic_warning_text(self.0, c_p0.as_ptr()) } + } + fn display_debug_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_output_window_display_debug_text( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_output_window_display_debug_text(self.0, c_p0.as_ptr()) } + } + fn prompt_user_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_prompt_user_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_output_window_prompt_user_on(self.0) } + } + fn prompt_user_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_prompt_user_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_output_window_prompt_user_off(self.0) } + } + fn set_prompt_user(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_output_window_set_prompt_user( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_output_window_set_prompt_user(self.0, _arg) } + } + fn set_use_std_error_for_all_messages(&mut self, p0: bool) -> () { + unsafe extern "C" { + fn vtk_output_window_set_use_std_error_for_all_messages( + sself: *mut core::ffi::c_void, + p0: bool, + ); + } + unsafe { vtk_output_window_set_use_std_error_for_all_messages(self.0, p0) } + } + fn get_use_std_error_for_all_messages(&mut self) -> bool { + unsafe extern "C" { + fn vtk_output_window_get_use_std_error_for_all_messages( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_output_window_get_use_std_error_for_all_messages(self.0) } + } + fn use_std_error_for_all_messages_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_use_std_error_for_all_messages_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_use_std_error_for_all_messages_on(self.0) } + } + fn use_std_error_for_all_messages_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_use_std_error_for_all_messages_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_use_std_error_for_all_messages_off(self.0) } + } + fn set_display_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_output_window_set_display_mode(self.0, _arg) } + } + fn get_display_mode_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_output_window_get_display_mode_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_output_window_get_display_mode_min_value(self.0) } + } + fn get_display_mode_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_output_window_get_display_mode_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_output_window_get_display_mode_max_value(self.0) } + } + fn get_display_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_output_window_get_display_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_output_window_get_display_mode(self.0) } + } + fn set_display_mode_to_default(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode_to_default( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_display_mode_to_default(self.0) } + } + fn set_display_mode_to_never(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode_to_never( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_display_mode_to_never(self.0) } + } + fn set_display_mode_to_always(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode_to_always( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_display_mode_to_always(self.0) } + } + fn set_display_mode_to_always_std_err(&mut self) -> () { + unsafe extern "C" { + fn vtk_output_window_set_display_mode_to_always_std_err( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_output_window_set_display_mode_to_always_std_err(self.0) } + } +} +impl VtkOverrideInformationCollection for vtkOverrideInformationCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_override_information_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_override_information_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_override_information_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_override_information_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_override_information_collection_add_item(self.0, p0) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_override_information_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_override_information_collection_get_next_item(self.0) } + } +} +impl VtkPoints for vtkPoints { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_new( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_new(self.0, dataType) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_initialize(self.0) } + } + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_set_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_set_data(self.0, p0) } + } + fn get_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_get_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_get_data(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_get_data_type(self.0) } + } + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + ); + } + unsafe { vtk_points_set_data_type(self.0, dataType) } + } + fn set_data_type_to_bit(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_bit(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_bit(self.0) } + } + fn set_data_type_to_char(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_char(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_char(self.0) } + } + fn set_data_type_to_unsigned_char(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_unsigned_char(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_unsigned_char(self.0) } + } + fn set_data_type_to_short(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_short(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_short(self.0) } + } + fn set_data_type_to_unsigned_short(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_unsigned_short(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_unsigned_short(self.0) } + } + fn set_data_type_to_int(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_int(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_int(self.0) } + } + fn set_data_type_to_unsigned_int(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_unsigned_int(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_unsigned_int(self.0) } + } + fn set_data_type_to_long(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_long(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_long(self.0) } + } + fn set_data_type_to_unsigned_long(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_unsigned_long(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_unsigned_long(self.0) } + } + fn set_data_type_to_float(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_float(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_float(self.0) } + } + fn set_data_type_to_double(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_set_data_type_to_double(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_set_data_type_to_double(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_reset(self.0) } + } + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_deep_copy( + sself: *mut core::ffi::c_void, + ad: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_deep_copy(self.0, ad) } + } + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_shallow_copy( + sself: *mut core::ffi::c_void, + ad: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_shallow_copy(self.0, ad) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_points_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_points_get_actual_memory_size(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_points_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_points_get_number_of_points(self.0) } + } + fn set_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_points_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_points_set_point(self.0, id, x, y, z) } + } + fn insert_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_points_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_points_insert_point(self.0, id, x, y, z) } + } + fn insert_points( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_points_insert_points( + sself: *mut core::ffi::c_void, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_insert_points(self.0, dstIds, srcIds, source) } + } + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_points_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_points_insert_next_point(self.0, x, y, z) } + } + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_points_set_number_of_points( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + ); + } + unsafe { vtk_points_set_number_of_points(self.0, numPoints) } + } + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_resize( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_resize(self.0, numPoints) } + } + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + outPoints: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_points_get_points( + sself: *mut core::ffi::c_void, + ptId: *mut core::ffi::c_void, + outPoints: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_get_points(self.0, ptId, outPoints) } + } + fn compute_bounds(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_compute_bounds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_compute_bounds(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_points_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_points_get_m_time(self.0) } + } + fn modified(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_modified(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_modified(self.0) } + } +} +impl VtkPoints2D for vtkPoints2D { + fn new(&mut self, dataType: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_new( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_new(self.0, dataType) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_2_d_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_2_d_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_initialize(self.0) } + } + fn set_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data(self.0, p0) } + } + fn get_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_2_d_get_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_2_d_get_data(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_2_d_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_2_d_get_data_type(self.0) } + } + fn set_data_type(&mut self, dataType: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + ); + } + unsafe { vtk_points_2_d_set_data_type(self.0, dataType) } + } + fn set_data_type_to_bit(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_bit(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_bit(self.0) } + } + fn set_data_type_to_char(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_char(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_char(self.0) } + } + fn set_data_type_to_unsigned_char(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_unsigned_char( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data_type_to_unsigned_char(self.0) } + } + fn set_data_type_to_short(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_short(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_short(self.0) } + } + fn set_data_type_to_unsigned_short(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_unsigned_short( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data_type_to_unsigned_short(self.0) } + } + fn set_data_type_to_int(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_int(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_int(self.0) } + } + fn set_data_type_to_unsigned_int(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_unsigned_int( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data_type_to_unsigned_int(self.0) } + } + fn set_data_type_to_long(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_long(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_long(self.0) } + } + fn set_data_type_to_unsigned_long(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_unsigned_long( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_set_data_type_to_unsigned_long(self.0) } + } + fn set_data_type_to_float(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_float(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_float(self.0) } + } + fn set_data_type_to_double(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_data_type_to_double(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_set_data_type_to_double(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_reset(self.0) } + } + fn deep_copy(&mut self, ad: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_2_d_deep_copy( + sself: *mut core::ffi::c_void, + ad: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_deep_copy(self.0, ad) } + } + fn shallow_copy(&mut self, ad: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_points_2_d_shallow_copy( + sself: *mut core::ffi::c_void, + ad: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_shallow_copy(self.0, ad) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_points_2_d_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_points_2_d_get_actual_memory_size(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_points_2_d_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_points_2_d_get_number_of_points(self.0) } + } + fn set_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_points_2_d_set_point(self.0, id, x, y) } + } + fn insert_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_points_2_d_insert_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_points_2_d_insert_point(self.0, id, x, y) } + } + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_points_2_d_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_points_2_d_insert_next_point(self.0, x, y) } + } + fn remove_point(&mut self, id: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_points_2_d_remove_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_points_2_d_remove_point(self.0, id) } + } + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_points_2_d_set_number_of_points( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + ); + } + unsafe { vtk_points_2_d_set_number_of_points(self.0, numPoints) } + } + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_2_d_resize( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_2_d_resize(self.0, numPoints) } + } + fn get_points( + &mut self, + ptId: *mut core::ffi::c_void, + fp: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_points_2_d_get_points( + sself: *mut core::ffi::c_void, + ptId: *mut core::ffi::c_void, + fp: *mut core::ffi::c_void, + ); + } + unsafe { vtk_points_2_d_get_points(self.0, ptId, fp) } + } + fn compute_bounds(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_2_d_compute_bounds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_2_d_compute_bounds(self.0) } + } +} +impl VtkPriorityQueue for vtkPriorityQueue { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_priority_queue_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_priority_queue_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_priority_queue_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_priority_queue_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_priority_queue_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_priority_queue_new_instance(self.0) } + } + fn allocate(&mut self, sz: core::ffi::c_longlong, ext: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_priority_queue_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ); + } + unsafe { vtk_priority_queue_allocate(self.0, sz, ext) } + } + fn insert( + &mut self, + priority: core::ffi::c_double, + id: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_priority_queue_insert( + sself: *mut core::ffi::c_void, + priority: core::ffi::c_double, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_priority_queue_insert(self.0, priority, id) } + } + fn pop( + &mut self, + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_priority_queue_pop( + sself: *mut core::ffi::c_void, + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_priority_queue_pop(self.0, location, priority) } + } + fn peek( + &mut self, + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_priority_queue_peek( + sself: *mut core::ffi::c_void, + location: core::ffi::c_longlong, + priority: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_priority_queue_peek(self.0, location, priority) } + } + fn delete_id(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_priority_queue_delete_id( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_double; + } + unsafe { vtk_priority_queue_delete_id(self.0, id) } + } + fn get_priority(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_priority_queue_get_priority( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_double; + } + unsafe { vtk_priority_queue_get_priority(self.0, id) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_priority_queue_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_priority_queue_get_number_of_items(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_priority_queue_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_priority_queue_reset(self.0) } + } +} +impl VtkRandomPool for vtkRandomPool { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_pool_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_pool_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_pool_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_pool_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_pool_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_pool_new_instance(self.0) } + } + fn set_sequence(&mut self, seq: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_random_pool_set_sequence( + sself: *mut core::ffi::c_void, + seq: *mut core::ffi::c_void, + ); + } + unsafe { vtk_random_pool_set_sequence(self.0, seq) } + } + fn get_sequence(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_pool_get_sequence( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_pool_get_sequence(self.0) } + } + fn set_size(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_random_pool_set_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_random_pool_set_size(self.0, _arg) } + } + fn get_size_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_size_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_size_min_value(self.0) } + } + fn get_size_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_size_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_size_max_value(self.0) } + } + fn get_size(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_size(self.0) } + } + fn set_number_of_components(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_random_pool_set_number_of_components( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_random_pool_set_number_of_components(self.0, _arg) } + } + fn get_number_of_components_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_number_of_components_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_number_of_components_min_value(self.0) } + } + fn get_number_of_components_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_number_of_components_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_number_of_components_max_value(self.0) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_number_of_components(self.0) } + } + fn get_total_size(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_total_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_total_size(self.0) } + } + fn get_value(&mut self, i: core::ffi::c_longlong) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_pool_get_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_pool_get_value(self.0, i) } + } + fn populate_data_array( + &mut self, + da: *mut core::ffi::c_void, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_random_pool_populate_data_array( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + minRange: core::ffi::c_double, + maxRange: core::ffi::c_double, + ); + } + unsafe { vtk_random_pool_populate_data_array(self.0, da, minRange, maxRange) } + } + fn set_chunk_size(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_random_pool_set_chunk_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_random_pool_set_chunk_size(self.0, _arg) } + } + fn get_chunk_size_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_chunk_size_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_chunk_size_min_value(self.0) } + } + fn get_chunk_size_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_chunk_size_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_chunk_size_max_value(self.0) } + } + fn get_chunk_size(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_pool_get_chunk_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_pool_get_chunk_size(self.0) } + } +} +impl VtkReferenceCount for vtkReferenceCount { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reference_count_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reference_count_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reference_count_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reference_count_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reference_count_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reference_count_new_instance(self.0) } + } +} +impl VtkScalarsToColors for vtkScalarsToColors { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_new(self.0) } + } + fn is_opaque(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_is_opaque( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_is_opaque(self.0) } + } + fn build(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_build(sself: *mut core::ffi::c_void); + } + unsafe { vtk_scalars_to_colors_build(self.0) } + } + fn set_range(&mut self, min: core::ffi::c_double, max: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_range( + sself: *mut core::ffi::c_void, + min: core::ffi::c_double, + max: core::ffi::c_double, + ); + } + unsafe { vtk_scalars_to_colors_set_range(self.0, min, max) } + } + fn get_opacity(&mut self, v: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_opacity( + sself: *mut core::ffi::c_void, + v: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_scalars_to_colors_get_opacity(self.0, v) } + } + fn get_luminance(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_luminance( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_scalars_to_colors_get_luminance(self.0, x) } + } + fn set_alpha(&mut self, alpha: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_alpha( + sself: *mut core::ffi::c_void, + alpha: core::ffi::c_double, + ); + } + unsafe { vtk_scalars_to_colors_set_alpha(self.0, alpha) } + } + fn get_alpha(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_alpha( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_scalars_to_colors_get_alpha(self.0) } + } + fn map_scalars( + &mut self, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_map_scalars( + sself: *mut core::ffi::c_void, + scalars: *mut core::ffi::c_void, + colorMode: core::ffi::c_int, + component: core::ffi::c_int, + outputFormat: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_scalars_to_colors_map_scalars( + self.0, + scalars, + colorMode, + component, + outputFormat, + ) + } + } + fn set_vector_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_mode(self.0, _arg) } + } + fn get_vector_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_vector_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_get_vector_mode(self.0) } + } + fn set_vector_mode_to_magnitude(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_mode_to_magnitude( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_mode_to_magnitude(self.0) } + } + fn set_vector_mode_to_component(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_mode_to_component( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_mode_to_component(self.0) } + } + fn set_vector_mode_to_rgb_colors(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_mode_to_rgb_colors( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_mode_to_rgb_colors(self.0) } + } + fn set_vector_component(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_component( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_component(self.0, _arg) } + } + fn get_vector_component(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_vector_component( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_get_vector_component(self.0) } + } + fn set_vector_size(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_vector_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_scalars_to_colors_set_vector_size(self.0, _arg) } + } + fn get_vector_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_vector_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_get_vector_size(self.0) } + } + fn deep_copy(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_deep_copy( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_deep_copy(self.0, o) } + } + fn using_log_scale(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_using_log_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_using_log_scale(self.0) } + } + fn get_number_of_available_colors(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_number_of_available_colors( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_scalars_to_colors_get_number_of_available_colors(self.0) } + } + fn set_annotations( + &mut self, + values: *mut core::ffi::c_void, + annotations: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_annotations( + sself: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + annotations: *mut core::ffi::c_void, + ); + } + unsafe { vtk_scalars_to_colors_set_annotations(self.0, values, annotations) } + } + fn get_annotated_values(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotated_values( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_get_annotated_values(self.0) } + } + fn get_annotations(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_annotations( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_scalars_to_colors_get_annotations(self.0) } + } + fn get_number_of_annotated_values(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_number_of_annotated_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_scalars_to_colors_get_number_of_annotated_values(self.0) } + } + fn reset_annotations(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_reset_annotations(sself: *mut core::ffi::c_void); + } + unsafe { vtk_scalars_to_colors_reset_annotations(self.0) } + } + fn set_indexed_lookup(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_set_indexed_lookup( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_scalars_to_colors_set_indexed_lookup(self.0, _arg) } + } + fn get_indexed_lookup(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_scalars_to_colors_get_indexed_lookup( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_scalars_to_colors_get_indexed_lookup(self.0) } + } + fn indexed_lookup_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_indexed_lookup_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_scalars_to_colors_indexed_lookup_on(self.0) } + } + fn indexed_lookup_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_scalars_to_colors_indexed_lookup_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_scalars_to_colors_indexed_lookup_off(self.0) } + } +} +impl VtkShortArray for vtkShortArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_short_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_short_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_short; + } + unsafe { vtk_short_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_short) -> () { + unsafe extern "C" { + fn vtk_short_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_short, + ); + } + unsafe { vtk_short_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_short_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_short_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_short) -> () { + unsafe extern "C" { + fn vtk_short_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_short, + ); + } + unsafe { vtk_short_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_short) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_short_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_short, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_short_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_short_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_short_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_short; + } + unsafe { vtk_short_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_short { + unsafe extern "C" { + fn vtk_short_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_short; + } + unsafe { vtk_short_array_get_data_type_value_max(self.0) } + } +} +impl VtkSignedCharArray for vtkSignedCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_signed_char_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_signed_char_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_schar { + unsafe extern "C" { + fn vtk_signed_char_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_schar; + } + unsafe { vtk_signed_char_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_schar) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_schar, + ); + } + unsafe { vtk_signed_char_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_signed_char_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_signed_char_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_schar) -> () { + unsafe extern "C" { + fn vtk_signed_char_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_schar, + ); + } + unsafe { vtk_signed_char_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_schar) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_signed_char_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_schar, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_signed_char_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_signed_char_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_signed_char_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_schar { + unsafe extern "C" { + fn vtk_signed_char_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_schar; + } + unsafe { vtk_signed_char_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_schar { + unsafe extern "C" { + fn vtk_signed_char_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_schar; + } + unsafe { vtk_signed_char_array_get_data_type_value_max(self.0) } + } +} +impl VtkSortDataArray for vtkSortDataArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_data_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_data_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_data_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_data_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_data_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_data_array_new_instance(self.0) } + } + fn sort(&mut self, keys: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort( + sself: *mut core::ffi::c_void, + keys: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sort_data_array_sort(self.0, keys) } + } + fn sort_array_by_component( + &mut self, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_sort_data_array_sort_array_by_component( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + k: core::ffi::c_int, + ); + } + unsafe { vtk_sort_data_array_sort_array_by_component(self.0, arr, k) } + } +} +impl VtkStringArray for vtkStringArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_new_instance(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_get_data_type(self.0) } + } + fn is_numeric(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_is_numeric( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_is_numeric(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_string_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_string_array_initialize(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_get_data_type_size(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_string_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_string_array_squeeze(self.0) } + } + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_resize( + sself: *mut core::ffi::c_void, + numTuples: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_resize(self.0, numTuples) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_insert_tuple(self.0, i, j, source) } + } + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_insert_tuples(self.0, dstIds, srcIds, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_string_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_string_array_insert_next_tuple(self.0, j, source) } + } + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_get_tuples( + sself: *mut core::ffi::c_void, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_get_tuples(self.0, ptIds, output) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_allocate(self.0, sz, ext) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_string_array_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ); + } + unsafe { vtk_string_array_set_number_of_tuples(self.0, number) } + } + fn get_number_of_values(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_string_array_get_number_of_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_string_array_get_number_of_values(self.0) } + } + fn get_number_of_element_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_get_number_of_element_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_get_number_of_element_components(self.0) } + } + fn get_element_component_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_string_array_get_element_component_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_string_array_get_element_component_size(self.0) } + } + fn write_pointer( + &mut self, + id: core::ffi::c_longlong, + number: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_write_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + number: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_write_pointer(self.0, id, number) } + } + fn get_pointer(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_get_pointer(self.0, id) } + } + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_string_array_deep_copy( + sself: *mut core::ffi::c_void, + aa: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_deep_copy(self.0, aa) } + } + fn set_array( + &mut self, + array: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_string_array_set_array( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_string_array_set_array(self.0, array, size, save, deleteMethod) } + } + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_string_array_set_array_free_function( + sself: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, + ); + } + unsafe { vtk_string_array_set_array_free_function(self.0, callback) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_string_array_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_string_array_get_actual_memory_size(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_array_new_iterator(self.0) } + } + fn get_data_size(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_string_array_get_data_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_string_array_get_data_size(self.0) } + } + fn data_changed(&mut self) -> () { + unsafe extern "C" { + fn vtk_string_array_data_changed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_string_array_data_changed(self.0) } + } + fn data_element_changed(&mut self, id: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_string_array_data_element_changed( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_string_array_data_element_changed(self.0, id) } + } + fn clear_lookup(&mut self) -> () { + unsafe extern "C" { + fn vtk_string_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_string_array_clear_lookup(self.0) } + } +} +impl VtkStringOutputWindow for vtkStringOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_output_window_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_output_window_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_output_window_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_output_window_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_string_output_window_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_string_output_window_new(self.0) } + } + fn display_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_string_output_window_display_text( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_string_output_window_display_text(self.0, c_p0.as_ptr()) } + } +} +impl VtkTimePointUtility for vtkTimePointUtility { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_time_point_utility_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_time_point_utility_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_time_point_utility_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_time_point_utility_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_time_point_utility_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_time_point_utility_new_instance(self.0) } + } + fn date_to_time_point( + &mut self, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_time_point_utility_date_to_time_point( + sself: *mut core::ffi::c_void, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_time_point_utility_date_to_time_point(self.0, year, month, day) } + } + fn time_to_time_point( + &mut self, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_time_point_utility_time_to_time_point( + sself: *mut core::ffi::c_void, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + second: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + } + unsafe { + vtk_time_point_utility_time_to_time_point( + self.0, + hour, + minute, + second, + millis, + ) + } + } + fn date_time_to_time_point( + &mut self, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + sec: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_time_point_utility_date_time_to_time_point( + sself: *mut core::ffi::c_void, + year: core::ffi::c_int, + month: core::ffi::c_int, + day: core::ffi::c_int, + hour: core::ffi::c_int, + minute: core::ffi::c_int, + sec: core::ffi::c_int, + millis: core::ffi::c_int, + ) -> core::ffi::c_ulonglong; + } + unsafe { + vtk_time_point_utility_date_time_to_time_point( + self.0, + year, + month, + day, + hour, + minute, + sec, + millis, + ) + } + } + fn get_date( + &mut self, + time: core::ffi::c_ulonglong, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_time_point_utility_get_date( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + ); + } + unsafe { vtk_time_point_utility_get_date(self.0, time, year, month, day) } + } + fn get_time( + &mut self, + time: core::ffi::c_ulonglong, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_time_point_utility_get_time( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, + ); + } + unsafe { + vtk_time_point_utility_get_time(self.0, time, hour, minute, second, millis) + } + } + fn get_date_time( + &mut self, + time: core::ffi::c_ulonglong, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_time_point_utility_get_date_time( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + year: &mut core::ffi::c_int, + month: &mut core::ffi::c_int, + day: &mut core::ffi::c_int, + hour: &mut core::ffi::c_int, + minute: &mut core::ffi::c_int, + second: &mut core::ffi::c_int, + millis: &mut core::ffi::c_int, + ); + } + unsafe { + vtk_time_point_utility_get_date_time( + self.0, + time, + year, + month, + day, + hour, + minute, + second, + millis, + ) + } + } + fn get_year(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_year( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_year(self.0, time) } + } + fn get_month(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_month( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_month(self.0, time) } + } + fn get_day(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_day( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_day(self.0, time) } + } + fn get_hour(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_hour( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_hour(self.0, time) } + } + fn get_minute(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_minute( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_minute(self.0, time) } + } + fn get_second(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_second( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_second(self.0, time) } + } + fn get_millisecond(&mut self, time: core::ffi::c_ulonglong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_time_point_utility_get_millisecond( + sself: *mut core::ffi::c_void, + time: core::ffi::c_ulonglong, + ) -> core::ffi::c_int; + } + unsafe { vtk_time_point_utility_get_millisecond(self.0, time) } + } + fn time_point_to_iso_8601( + &mut self, + p0: core::ffi::c_ulonglong, + format: core::ffi::c_int, + ) -> &str { + unsafe extern "C" { + fn vtk_time_point_utility_time_point_to_iso_8601( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_ulonglong, + format: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_time_point_utility_time_point_to_iso_8601(self.0, p0, format) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +impl VtkTypeFloat32Array for vtkTypeFloat32Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_32_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_32_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_32_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_32_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_32_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_32_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_32_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_32_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeFloat64Array for vtkTypeFloat64Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_64_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_64_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_64_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_64_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_64_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_64_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_float_64_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_float_64_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeInt16Array for vtkTypeInt16Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_16_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_16_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_16_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_16_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_16_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_16_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_16_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_16_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeInt32Array for vtkTypeInt32Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_32_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_32_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_32_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_32_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_32_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_32_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_32_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_32_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeInt64Array for vtkTypeInt64Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_64_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_64_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_64_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_64_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_64_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_64_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_64_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_64_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeInt8Array for vtkTypeInt8Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_8_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_8_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_8_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_8_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_8_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_8_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_int_8_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_int_8_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeUInt16Array for vtkTypeUInt16Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_16_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_16_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_16_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_16_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_16_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_16_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_16_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_16_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeUInt32Array for vtkTypeUInt32Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_32_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_32_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_32_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_32_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_32_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_32_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_32_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_32_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeUInt64Array for vtkTypeUInt64Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_64_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_64_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_64_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_64_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_64_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_64_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_64_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_64_array_fast_down_cast(self.0, source) } + } +} +impl VtkTypeUInt8Array for vtkTypeUInt8Array { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_8_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_8_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_8_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_8_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_8_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_8_array_new_instance(self.0) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_type_u_int_8_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_type_u_int_8_array_fast_down_cast(self.0, source) } + } +} +impl VtkUnicodeStringArray for vtkUnicodeStringArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unicode_string_array_initialize(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_get_data_type_size(self.0) } + } + fn get_element_component_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_get_element_component_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_get_element_component_size(self.0) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ); + } + unsafe { vtk_unicode_string_array_set_number_of_tuples(self.0, number) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_insert_tuple(self.0, i, j, source) } + } + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_insert_tuples(self.0, dstIds, srcIds, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_unicode_string_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_unicode_string_array_insert_next_tuple(self.0, j, source) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unicode_string_array_squeeze(self.0) } + } + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_resize( + sself: *mut core::ffi::c_void, + numTuples: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_resize(self.0, numTuples) } + } + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_set_array_free_function( + sself: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unicode_string_array_set_array_free_function(self.0, callback) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unicode_string_array_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unicode_string_array_get_actual_memory_size(self.0) } + } + fn is_numeric(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unicode_string_array_is_numeric( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unicode_string_array_is_numeric(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unicode_string_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unicode_string_array_new_iterator(self.0) } + } + fn data_changed(&mut self) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_data_changed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unicode_string_array_data_changed(self.0) } + } + fn clear_lookup(&mut self) -> () { + unsafe extern "C" { + fn vtk_unicode_string_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unicode_string_array_clear_lookup(self.0) } + } + fn insert_next_utf_8_value(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_unicode_string_array_insert_next_utf_8_value( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { + vtk_unicode_string_array_insert_next_utf_8_value(self.0, c_p0.as_ptr()) + } + } + fn set_utf_8_value(&mut self, i: core::ffi::c_longlong, p1: &str) -> () { + let c_p1 = std::ffi::CString::new(p1).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_unicode_string_array_set_utf_8_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + p1: *const core::ffi::c_char, + ); + } + unsafe { vtk_unicode_string_array_set_utf_8_value(self.0, i, c_p1.as_ptr()) } + } + fn get_utf_8_value(&mut self, i: core::ffi::c_longlong) -> &str { + unsafe extern "C" { + fn vtk_unicode_string_array_get_utf_8_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_unicode_string_array_get_utf_8_value(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +impl VtkUnsignedCharArray for vtkUnsignedCharArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_char_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_uchar, + ); + } + unsafe { vtk_unsigned_char_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_unsigned_char_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_unsigned_char_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_unsigned_char_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_uchar, + ); + } + unsafe { vtk_unsigned_char_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_uchar) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_unsigned_char_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_uchar, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_unsigned_char_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_char_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_char_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_unsigned_char_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_unsigned_char_array_get_data_type_value_max(self.0) } + } +} +impl VtkUnsignedIntArray for vtkUnsignedIntArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_int_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_uint, + ); + } + unsafe { vtk_unsigned_int_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_unsigned_int_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_unsigned_int_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_unsigned_int_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_uint, + ); + } + unsafe { vtk_unsigned_int_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_uint) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_unsigned_int_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_uint, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_unsigned_int_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_int_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_int_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_unsigned_int_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_unsigned_int_array_get_data_type_value_max(self.0) } + } +} +impl VtkUnsignedLongArray for vtkUnsignedLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_long_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_value(self.0, id) } + } + fn set_value(&mut self, id: core::ffi::c_longlong, value: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_ulong, + ); + } + unsafe { vtk_unsigned_long_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_unsigned_long_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_unsigned_long_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_ulong) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_ulong, + ); + } + unsafe { vtk_unsigned_long_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_ulong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_unsigned_long_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_ulong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_unsigned_long_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unsigned_long_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unsigned_long_array_get_data_type_value_max(self.0) } + } +} +impl VtkUnsignedLongLongArray for vtkUnsignedLongLongArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_long_long_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_value(self.0, id) } + } + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_ulonglong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_unsigned_long_long_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_unsigned_long_long_array_set_number_of_values(self.0, number) } + } + fn insert_value( + &mut self, + id: core::ffi::c_longlong, + f: core::ffi::c_ulonglong, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_ulonglong, + ); + } + unsafe { vtk_unsigned_long_long_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_ulonglong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_ulonglong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_unsigned_long_long_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_long_long_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_ulonglong { + unsafe extern "C" { + fn vtk_unsigned_long_long_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulonglong; + } + unsafe { vtk_unsigned_long_long_array_get_data_type_value_max(self.0) } + } +} +impl VtkUnsignedShortArray for vtkUnsignedShortArray { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_extended_new(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unsigned_short_array_get_data_type(self.0) } + } + fn get_value(&mut self, id: core::ffi::c_longlong) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_value(self.0, id) } + } + fn set_value( + &mut self, + id: core::ffi::c_longlong, + value: core::ffi::c_ushort, + ) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_set_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + value: core::ffi::c_ushort, + ); + } + unsafe { vtk_unsigned_short_array_set_value(self.0, id, value) } + } + fn set_number_of_values(&mut self, number: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_unsigned_short_array_set_number_of_values( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_unsigned_short_array_set_number_of_values(self.0, number) } + } + fn insert_value(&mut self, id: core::ffi::c_longlong, f: core::ffi::c_ushort) -> () { + unsafe extern "C" { + fn vtk_unsigned_short_array_insert_value( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + f: core::ffi::c_ushort, + ); + } + unsafe { vtk_unsigned_short_array_insert_value(self.0, id, f) } + } + fn insert_next_value(&mut self, f: core::ffi::c_ushort) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_unsigned_short_array_insert_next_value( + sself: *mut core::ffi::c_void, + f: core::ffi::c_ushort, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_unsigned_short_array_insert_next_value(self.0, f) } + } + fn fast_down_cast( + &mut self, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unsigned_short_array_fast_down_cast( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unsigned_short_array_fast_down_cast(self.0, source) } + } + fn get_data_type_value_min(&mut self) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_data_type_value_min( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_data_type_value_min(self.0) } + } + fn get_data_type_value_max(&mut self) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_unsigned_short_array_get_data_type_value_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_unsigned_short_array_get_data_type_value_max(self.0) } + } +} +impl VtkVariantArray for vtkVariantArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_variant_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_variant_array_initialize(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_get_data_type_size(self.0) } + } + fn get_element_component_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_get_element_component_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_get_element_component_size(self.0) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ); + } + unsafe { vtk_variant_array_set_number_of_tuples(self.0, number) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_insert_tuple(self.0, i, j, source) } + } + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_insert_tuples( + sself: *mut core::ffi::c_void, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_insert_tuples(self.0, dstIds, srcIds, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_variant_array_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_variant_array_insert_next_tuple(self.0, j, source) } + } + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_variant_array_deep_copy( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_deep_copy(self.0, da) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_variant_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_variant_array_squeeze(self.0) } + } + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_resize( + sself: *mut core::ffi::c_void, + numTuples: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_resize(self.0, numTuples) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_variant_array_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_variant_array_get_actual_memory_size(self.0) } + } + fn is_numeric(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_variant_array_is_numeric( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_variant_array_is_numeric(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_new_iterator(self.0) } + } + fn get_pointer(&mut self, id: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_variant_array_get_pointer( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_variant_array_get_pointer(self.0, id) } + } + fn set_array( + &mut self, + arr: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_array( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + save: core::ffi::c_int, + deleteMethod: core::ffi::c_int, + ); + } + unsafe { vtk_variant_array_set_array(self.0, arr, size, save, deleteMethod) } + } + fn set_array_free_function(&mut self, callback: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_variant_array_set_array_free_function( + sself: *mut core::ffi::c_void, + callback: *mut core::ffi::c_void, + ); + } + unsafe { vtk_variant_array_set_array_free_function(self.0, callback) } + } + fn get_number_of_values(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_variant_array_get_number_of_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_variant_array_get_number_of_values(self.0) } + } + fn data_changed(&mut self) -> () { + unsafe extern "C" { + fn vtk_variant_array_data_changed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_variant_array_data_changed(self.0) } + } + fn data_element_changed(&mut self, id: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_variant_array_data_element_changed( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_variant_array_data_element_changed(self.0, id) } + } + fn clear_lookup(&mut self) -> () { + unsafe extern "C" { + fn vtk_variant_array_clear_lookup(sself: *mut core::ffi::c_void); + } + unsafe { vtk_variant_array_clear_lookup(self.0) } + } +} +impl VtkVersion for vtkVersion { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_version_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_version_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_version_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_version_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_version_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_version_new_instance(self.0) } + } + fn get_vtk_version(&mut self) -> &str { + unsafe extern "C" { + fn vtk_version_get_vtk_version( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_version_get_vtk_version(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_vtk_version_full(&mut self) -> &str { + unsafe extern "C" { + fn vtk_version_get_vtk_version_full( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_version_get_vtk_version_full(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_vtk_major_version(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_version_get_vtk_major_version( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_version_get_vtk_major_version(self.0) } + } + fn get_vtk_minor_version(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_version_get_vtk_minor_version( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_version_get_vtk_minor_version(self.0) } + } + fn get_vtk_build_version(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_version_get_vtk_build_version( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_version_get_vtk_build_version(self.0) } + } + fn get_vtk_source_version(&mut self) -> &str { + unsafe extern "C" { + fn vtk_version_get_vtk_source_version( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_version_get_vtk_source_version(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +impl VtkVoidArray for vtkVoidArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_void_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_void_array_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_void_array_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_void_array_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_void_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_void_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_void_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_void_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_void_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_void_array_allocate(self.0, sz, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_void_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_void_array_initialize(self.0) } + } + fn get_data_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_void_array_get_data_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_void_array_get_data_type(self.0) } + } + fn get_data_type_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_void_array_get_data_type_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_void_array_get_data_type_size(self.0) } + } + fn set_number_of_pointers(&mut self, number: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_void_array_set_number_of_pointers( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ); + } + unsafe { vtk_void_array_set_number_of_pointers(self.0, number) } + } + fn get_number_of_pointers(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_void_array_get_number_of_pointers( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_void_array_get_number_of_pointers(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_void_array_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_void_array_reset(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_void_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_void_array_squeeze(self.0) } + } + fn deep_copy(&mut self, va: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_void_array_deep_copy( + sself: *mut core::ffi::c_void, + va: *mut core::ffi::c_void, + ); + } + unsafe { vtk_void_array_deep_copy(self.0, va) } + } +} +impl VtkWeakReference for vtkWeakReference { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_weak_reference_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_weak_reference_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_weak_reference_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_weak_reference_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_weak_reference_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_weak_reference_new(self.0) } + } + fn set(&mut self, object: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_weak_reference_set( + sself: *mut core::ffi::c_void, + object: *mut core::ffi::c_void, + ); + } + unsafe { vtk_weak_reference_set(self.0, object) } + } + fn get(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_weak_reference_get( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_weak_reference_get(self.0) } + } +} +impl VtkXMLFileOutputWindow for vtkXMLFileOutputWindow { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_file_output_window_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_file_output_window_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_file_output_window_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_file_output_window_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_file_output_window_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_file_output_window_new(self.0) } + } + fn display_text(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_file_output_window_display_text( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_xml_file_output_window_display_text(self.0, c_p0.as_ptr()) } + } + fn display_tag(&mut self, p0: &str) -> () { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_file_output_window_display_tag( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ); + } + unsafe { vtk_xml_file_output_window_display_tag(self.0, c_p0.as_ptr()) } + } +} /// a seqin an animation. /// /// @@ -21,22 +11789,13 @@ #[allow(non_camel_case_types)] pub struct vtkAnimationCue(*mut core::ffi::c_void); impl vtkAnimationCue { - /// Creates a new [vtkAnimationCue] wrapped inside `vtkNew` + /// Creates a new [vtkAnimationCue] via `vtkAnimationCue::New()` #[doc(alias = "vtkAnimationCue")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnimationCue_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnimationCue_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnimationCue_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnimationCue_get_ptr(self.0) } + Self(unsafe { vtkAnimationCue_new() }) } } impl std::default::Default for vtkAnimationCue { @@ -56,12 +11815,8 @@ impl Drop for vtkAnimationCue { #[test] fn test_vtkAnimationCue_create_drop() { let obj = vtkAnimationCue::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnimationCue(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Writes an archive /// @@ -75,22 +11830,13 @@ fn test_vtkAnimationCue_create_drop() { #[allow(non_camel_case_types)] pub struct vtkArchiver(*mut core::ffi::c_void); impl vtkArchiver { - /// Creates a new [vtkArchiver] wrapped inside `vtkNew` + /// Creates a new [vtkArchiver] via `vtkArchiver::New()` #[doc(alias = "vtkArchiver")] pub fn new() -> Self { unsafe extern "C" { fn vtkArchiver_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkArchiver_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkArchiver_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkArchiver_get_ptr(self.0) } + Self(unsafe { vtkArchiver_new() }) } } impl std::default::Default for vtkArchiver { @@ -110,12 +11856,8 @@ impl Drop for vtkArchiver { #[test] fn test_vtkArchiver_create_drop() { let obj = vtkArchiver::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkArchiver(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of bits /// @@ -127,22 +11869,13 @@ fn test_vtkArchiver_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBitArray(*mut core::ffi::c_void); impl vtkBitArray { - /// Creates a new [vtkBitArray] wrapped inside `vtkNew` + /// Creates a new [vtkBitArray] via `vtkBitArray::New()` #[doc(alias = "vtkBitArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkBitArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBitArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBitArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBitArray_get_ptr(self.0) } + Self(unsafe { vtkBitArray_new() }) } } impl std::default::Default for vtkBitArray { @@ -162,12 +11895,8 @@ impl Drop for vtkBitArray { #[test] fn test_vtkBitArray_create_drop() { let obj = vtkBitArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBitArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterator for vtkBitArray. /// @@ -176,22 +11905,13 @@ fn test_vtkBitArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBitArrayIterator(*mut core::ffi::c_void); impl vtkBitArrayIterator { - /// Creates a new [vtkBitArrayIterator] wrapped inside `vtkNew` + /// Creates a new [vtkBitArrayIterator] via `vtkBitArrayIterator::New()` #[doc(alias = "vtkBitArrayIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkBitArrayIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBitArrayIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBitArrayIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBitArrayIterator_get_ptr(self.0) } + Self(unsafe { vtkBitArrayIterator_new() }) } } impl std::default::Default for vtkBitArrayIterator { @@ -211,12 +11931,8 @@ impl Drop for vtkBitArrayIterator { #[test] fn test_vtkBitArrayIterator_create_drop() { let obj = vtkBitArrayIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBitArrayIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform /// @@ -230,22 +11946,13 @@ fn test_vtkBitArrayIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBoxMuellerRandomSequence(*mut core::ffi::c_void); impl vtkBoxMuellerRandomSequence { - /// Creates a new [vtkBoxMuellerRandomSequence] wrapped inside `vtkNew` + /// Creates a new [vtkBoxMuellerRandomSequence] via `vtkBoxMuellerRandomSequence::New()` #[doc(alias = "vtkBoxMuellerRandomSequence")] pub fn new() -> Self { unsafe extern "C" { fn vtkBoxMuellerRandomSequence_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBoxMuellerRandomSequence_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBoxMuellerRandomSequence_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBoxMuellerRandomSequence_get_ptr(self.0) } + Self(unsafe { vtkBoxMuellerRandomSequence_new() }) } } impl std::default::Default for vtkBoxMuellerRandomSequence { @@ -265,12 +11972,8 @@ impl Drop for vtkBoxMuellerRandomSequence { #[test] fn test_vtkBoxMuellerRandomSequence_create_drop() { let obj = vtkBoxMuellerRandomSequence::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBoxMuellerRandomSequence(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// perform machine dependent byte swapping /// @@ -281,22 +11984,13 @@ fn test_vtkBoxMuellerRandomSequence_create_drop() { #[allow(non_camel_case_types)] pub struct vtkByteSwap(*mut core::ffi::c_void); impl vtkByteSwap { - /// Creates a new [vtkByteSwap] wrapped inside `vtkNew` + /// Creates a new [vtkByteSwap] via `vtkByteSwap::New()` #[doc(alias = "vtkByteSwap")] pub fn new() -> Self { unsafe extern "C" { fn vtkByteSwap_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkByteSwap_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkByteSwap_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkByteSwap_get_ptr(self.0) } + Self(unsafe { vtkByteSwap_new() }) } } impl std::default::Default for vtkByteSwap { @@ -316,12 +12010,8 @@ impl Drop for vtkByteSwap { #[test] fn test_vtkByteSwap_create_drop() { let obj = vtkByteSwap::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkByteSwap(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// supports function callbacks /// @@ -346,22 +12036,13 @@ fn test_vtkByteSwap_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCallbackCommand(*mut core::ffi::c_void); impl vtkCallbackCommand { - /// Creates a new [vtkCallbackCommand] wrapped inside `vtkNew` + /// Creates a new [vtkCallbackCommand] via `vtkCallbackCommand::New()` #[doc(alias = "vtkCallbackCommand")] pub fn new() -> Self { unsafe extern "C" { fn vtkCallbackCommand_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCallbackCommand_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCallbackCommand_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCallbackCommand_get_ptr(self.0) } + Self(unsafe { vtkCallbackCommand_new() }) } } impl std::default::Default for vtkCallbackCommand { @@ -381,12 +12062,8 @@ impl Drop for vtkCallbackCommand { #[test] fn test_vtkCallbackCommand_create_drop() { let obj = vtkCallbackCommand::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCallbackCommand(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of char /// @@ -410,22 +12087,13 @@ fn test_vtkCallbackCommand_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCharArray(*mut core::ffi::c_void); impl vtkCharArray { - /// Creates a new [vtkCharArray] wrapped inside `vtkNew` + /// Creates a new [vtkCharArray] via `vtkCharArray::New()` #[doc(alias = "vtkCharArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkCharArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCharArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCharArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCharArray_get_ptr(self.0) } + Self(unsafe { vtkCharArray_new() }) } } impl std::default::Default for vtkCharArray { @@ -445,12 +12113,8 @@ impl Drop for vtkCharArray { #[test] fn test_vtkCharArray_create_drop() { let obj = vtkCharArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCharArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// create and manipulate ordered lists of objects /// @@ -468,22 +12132,13 @@ fn test_vtkCharArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCollection(*mut core::ffi::c_void); impl vtkCollection { - /// Creates a new [vtkCollection] wrapped inside `vtkNew` + /// Creates a new [vtkCollection] via `vtkCollection::New()` #[doc(alias = "vtkCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCollection_get_ptr(self.0) } + Self(unsafe { vtkCollection_new() }) } } impl std::default::Default for vtkCollection { @@ -503,12 +12158,8 @@ impl Drop for vtkCollection { #[test] fn test_vtkCollection_create_drop() { let obj = vtkCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// iterator through a vtkCollection. /// @@ -523,22 +12174,13 @@ fn test_vtkCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCollectionIterator(*mut core::ffi::c_void); impl vtkCollectionIterator { - /// Creates a new [vtkCollectionIterator] wrapped inside `vtkNew` + /// Creates a new [vtkCollectionIterator] via `vtkCollectionIterator::New()` #[doc(alias = "vtkCollectionIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkCollectionIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCollectionIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCollectionIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCollectionIterator_get_ptr(self.0) } + Self(unsafe { vtkCollectionIterator_new() }) } } impl std::default::Default for vtkCollectionIterator { @@ -558,12 +12200,8 @@ impl Drop for vtkCollectionIterator { #[test] fn test_vtkCollectionIterator_create_drop() { let obj = vtkCollectionIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCollectionIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Critical section locking class /// @@ -586,22 +12224,13 @@ fn test_vtkCollectionIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCriticalSection(*mut core::ffi::c_void); impl vtkCriticalSection { - /// Creates a new [vtkCriticalSection] wrapped inside `vtkNew` + /// Creates a new [vtkCriticalSection] via `vtkCriticalSection::New()` #[doc(alias = "vtkCriticalSection")] pub fn new() -> Self { unsafe extern "C" { fn vtkCriticalSection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCriticalSection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCriticalSection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCriticalSection_get_ptr(self.0) } + Self(unsafe { vtkCriticalSection_new() }) } } impl std::default::Default for vtkCriticalSection { @@ -621,12 +12250,8 @@ impl Drop for vtkCriticalSection { #[test] fn test_vtkCriticalSection_create_drop() { let obj = vtkCriticalSection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCriticalSection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain an ordered list of dataarray objects /// @@ -636,22 +12261,13 @@ fn test_vtkCriticalSection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataArrayCollection(*mut core::ffi::c_void); impl vtkDataArrayCollection { - /// Creates a new [vtkDataArrayCollection] wrapped inside `vtkNew` + /// Creates a new [vtkDataArrayCollection] via `vtkDataArrayCollection::New()` #[doc(alias = "vtkDataArrayCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataArrayCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataArrayCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataArrayCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataArrayCollection_get_ptr(self.0) } + Self(unsafe { vtkDataArrayCollection_new() }) } } impl std::default::Default for vtkDataArrayCollection { @@ -671,12 +12287,8 @@ impl Drop for vtkDataArrayCollection { #[test] fn test_vtkDataArrayCollection_create_drop() { let obj = vtkDataArrayCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataArrayCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// iterator through a vtkDataArrayCollection. /// @@ -687,22 +12299,13 @@ fn test_vtkDataArrayCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataArrayCollectionIterator(*mut core::ffi::c_void); impl vtkDataArrayCollectionIterator { - /// Creates a new [vtkDataArrayCollectionIterator] wrapped inside `vtkNew` + /// Creates a new [vtkDataArrayCollectionIterator] via `vtkDataArrayCollectionIterator::New()` #[doc(alias = "vtkDataArrayCollectionIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataArrayCollectionIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataArrayCollectionIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataArrayCollectionIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataArrayCollectionIterator_get_ptr(self.0) } + Self(unsafe { vtkDataArrayCollectionIterator_new() }) } } impl std::default::Default for vtkDataArrayCollectionIterator { @@ -722,50 +12325,27 @@ impl Drop for vtkDataArrayCollectionIterator { #[test] fn test_vtkDataArrayCollectionIterator_create_drop() { let obj = vtkDataArrayCollectionIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataArrayCollectionIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// Store on/off settings for data arrays, etc. -/// -/// -/// vtkDataArraySelection is intended to be used by algorithms that want to -/// expose a API that allow the user to enable/disable a collection of entities, -/// such as arrays. Readers, for example, can use vtkDataArraySelection to let -/// the user choose which array to read from the file. +/// Store on/off settings for data arrays for a vtkSource. /// -/// Originally intended for selecting data arrays (hence the name), this class -/// can be used for letting users choose other items too, for example, -/// vtkIOSSReader uses vtkDataArraySelection to let users choose -/// which blocks to read. /// -/// Unlike most other vtkObject subclasses, vtkDataArraySelection has public API -/// that need not modify the MTime for the object. These M-Time non-modifying -/// methods are typically intended for use within the algorithm or reader to -/// populate the vtkDataArraySelection instance with available array names and -/// their default values. +/// vtkDataArraySelection can be used by vtkSource subclasses to store +/// on/off settings for whether each vtkDataArray in its input should +/// be passed in the source's output. This is primarily intended to +/// allow file readers to configure what data arrays are read from the +/// file. #[allow(non_camel_case_types)] pub struct vtkDataArraySelection(*mut core::ffi::c_void); impl vtkDataArraySelection { - /// Creates a new [vtkDataArraySelection] wrapped inside `vtkNew` + /// Creates a new [vtkDataArraySelection] via `vtkDataArraySelection::New()` #[doc(alias = "vtkDataArraySelection")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataArraySelection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataArraySelection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataArraySelection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataArraySelection_get_ptr(self.0) } + Self(unsafe { vtkDataArraySelection_new() }) } } impl std::default::Default for vtkDataArraySelection { @@ -785,12 +12365,8 @@ impl Drop for vtkDataArraySelection { #[test] fn test_vtkDataArraySelection_create_drop() { let obj = vtkDataArraySelection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataArraySelection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// identify memory leaks at program termination /// @@ -826,22 +12402,13 @@ fn test_vtkDataArraySelection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDebugLeaks(*mut core::ffi::c_void); impl vtkDebugLeaks { - /// Creates a new [vtkDebugLeaks] wrapped inside `vtkNew` + /// Creates a new [vtkDebugLeaks] via `vtkDebugLeaks::New()` #[doc(alias = "vtkDebugLeaks")] pub fn new() -> Self { unsafe extern "C" { fn vtkDebugLeaks_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDebugLeaks_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDebugLeaks_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDebugLeaks_get_ptr(self.0) } + Self(unsafe { vtkDebugLeaks_new() }) } } impl std::default::Default for vtkDebugLeaks { @@ -861,12 +12428,8 @@ impl Drop for vtkDebugLeaks { #[test] fn test_vtkDebugLeaks_create_drop() { let obj = vtkDebugLeaks::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDebugLeaks(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of double /// @@ -877,22 +12440,13 @@ fn test_vtkDebugLeaks_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDoubleArray(*mut core::ffi::c_void); impl vtkDoubleArray { - /// Creates a new [vtkDoubleArray] wrapped inside `vtkNew` + /// Creates a new [vtkDoubleArray] via `vtkDoubleArray::New()` #[doc(alias = "vtkDoubleArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkDoubleArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDoubleArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDoubleArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDoubleArray_get_ptr(self.0) } + Self(unsafe { vtkDoubleArray_new() }) } } impl std::default::Default for vtkDoubleArray { @@ -912,12 +12466,8 @@ impl Drop for vtkDoubleArray { #[test] fn test_vtkDoubleArray_create_drop() { let obj = vtkDoubleArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDoubleArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// class interface to system dynamic libraries /// @@ -929,22 +12479,13 @@ fn test_vtkDoubleArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDynamicLoader(*mut core::ffi::c_void); impl vtkDynamicLoader { - /// Creates a new [vtkDynamicLoader] wrapped inside `vtkNew` + /// Creates a new [vtkDynamicLoader] via `vtkDynamicLoader::New()` #[doc(alias = "vtkDynamicLoader")] pub fn new() -> Self { unsafe extern "C" { fn vtkDynamicLoader_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDynamicLoader_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDynamicLoader_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDynamicLoader_get_ptr(self.0) } + Self(unsafe { vtkDynamicLoader_new() }) } } impl std::default::Default for vtkDynamicLoader { @@ -964,33 +12505,20 @@ impl Drop for vtkDynamicLoader { #[test] fn test_vtkDynamicLoader_create_drop() { let obj = vtkDynamicLoader::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDynamicLoader(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkEventDataDevice3D(*mut core::ffi::c_void); impl vtkEventDataDevice3D { - /// Creates a new [vtkEventDataDevice3D] wrapped inside `vtkNew` + /// Creates a new [vtkEventDataDevice3D] via `vtkEventDataDevice3D::New()` #[doc(alias = "vtkEventDataDevice3D")] pub fn new() -> Self { unsafe extern "C" { fn vtkEventDataDevice3D_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEventDataDevice3D_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEventDataDevice3D_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEventDataDevice3D_get_ptr(self.0) } + Self(unsafe { vtkEventDataDevice3D_new() }) } } impl std::default::Default for vtkEventDataDevice3D { @@ -1010,33 +12538,20 @@ impl Drop for vtkEventDataDevice3D { #[test] fn test_vtkEventDataDevice3D_create_drop() { let obj = vtkEventDataDevice3D::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEventDataDevice3D(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkEventDataForDevice(*mut core::ffi::c_void); impl vtkEventDataForDevice { - /// Creates a new [vtkEventDataForDevice] wrapped inside `vtkNew` + /// Creates a new [vtkEventDataForDevice] via `vtkEventDataForDevice::New()` #[doc(alias = "vtkEventDataForDevice")] pub fn new() -> Self { unsafe extern "C" { fn vtkEventDataForDevice_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEventDataForDevice_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEventDataForDevice_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEventDataForDevice_get_ptr(self.0) } + Self(unsafe { vtkEventDataForDevice_new() }) } } impl std::default::Default for vtkEventDataForDevice { @@ -1056,12 +12571,8 @@ impl Drop for vtkEventDataForDevice { #[test] fn test_vtkEventDataForDevice_create_drop() { let obj = vtkEventDataForDevice::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEventDataForDevice(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a simple event forwarder command /// @@ -1076,22 +12587,13 @@ fn test_vtkEventDataForDevice_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEventForwarderCommand(*mut core::ffi::c_void); impl vtkEventForwarderCommand { - /// Creates a new [vtkEventForwarderCommand] wrapped inside `vtkNew` + /// Creates a new [vtkEventForwarderCommand] via `vtkEventForwarderCommand::New()` #[doc(alias = "vtkEventForwarderCommand")] pub fn new() -> Self { unsafe extern "C" { fn vtkEventForwarderCommand_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEventForwarderCommand_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEventForwarderCommand_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEventForwarderCommand_get_ptr(self.0) } + Self(unsafe { vtkEventForwarderCommand_new() }) } } impl std::default::Default for vtkEventForwarderCommand { @@ -1111,12 +12613,8 @@ impl Drop for vtkEventForwarderCommand { #[test] fn test_vtkEventForwarderCommand_create_drop() { let obj = vtkEventForwarderCommand::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEventForwarderCommand(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// File Specific output window class /// @@ -1126,22 +12624,13 @@ fn test_vtkEventForwarderCommand_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFileOutputWindow(*mut core::ffi::c_void); impl vtkFileOutputWindow { - /// Creates a new [vtkFileOutputWindow] wrapped inside `vtkNew` + /// Creates a new [vtkFileOutputWindow] via `vtkFileOutputWindow::New()` #[doc(alias = "vtkFileOutputWindow")] pub fn new() -> Self { unsafe extern "C" { fn vtkFileOutputWindow_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFileOutputWindow_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFileOutputWindow_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkFileOutputWindow_get_ptr(self.0) } + Self(unsafe { vtkFileOutputWindow_new() }) } } impl std::default::Default for vtkFileOutputWindow { @@ -1161,12 +12650,8 @@ impl Drop for vtkFileOutputWindow { #[test] fn test_vtkFileOutputWindow_create_drop() { let obj = vtkFileOutputWindow::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFileOutputWindow(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of float /// @@ -1177,22 +12662,13 @@ fn test_vtkFileOutputWindow_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFloatArray(*mut core::ffi::c_void); impl vtkFloatArray { - /// Creates a new [vtkFloatArray] wrapped inside `vtkNew` + /// Creates a new [vtkFloatArray] via `vtkFloatArray::New()` #[doc(alias = "vtkFloatArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkFloatArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFloatArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFloatArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkFloatArray_get_ptr(self.0) } + Self(unsafe { vtkFloatArray_new() }) } } impl std::default::Default for vtkFloatArray { @@ -1212,12 +12688,8 @@ impl Drop for vtkFloatArray { #[test] fn test_vtkFloatArray_create_drop() { let obj = vtkFloatArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFloatArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Detect and break reference loops /// @@ -1237,7 +12709,14 @@ fn test_vtkFloatArray_create_drop() { /// \code /// /// public: -/// bool UsesGarbageCollector() const override { return true; } +/// void Register(vtkObjectBase* o) override +/// { +/// this->RegisterInternal(o, true); +/// } +/// void UnRegister(vtkObjectBase* o) override +/// { +/// this->UnRegisterInternal(o, true); +/// } /// /// protected: /// @@ -1276,22 +12755,13 @@ fn test_vtkFloatArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGarbageCollector(*mut core::ffi::c_void); impl vtkGarbageCollector { - /// Creates a new [vtkGarbageCollector] wrapped inside `vtkNew` + /// Creates a new [vtkGarbageCollector] via `vtkGarbageCollector::New()` #[doc(alias = "vtkGarbageCollector")] pub fn new() -> Self { unsafe extern "C" { fn vtkGarbageCollector_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGarbageCollector_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGarbageCollector_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGarbageCollector_get_ptr(self.0) } + Self(unsafe { vtkGarbageCollector_new() }) } } impl std::default::Default for vtkGarbageCollector { @@ -1311,12 +12781,8 @@ impl Drop for vtkGarbageCollector { #[test] fn test_vtkGarbageCollector_create_drop() { let obj = vtkGarbageCollector::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGarbageCollector(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// list of point or cell ids /// @@ -1327,22 +12793,13 @@ fn test_vtkGarbageCollector_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIdList(*mut core::ffi::c_void); impl vtkIdList { - /// Creates a new [vtkIdList] wrapped inside `vtkNew` + /// Creates a new [vtkIdList] via `vtkIdList::New()` #[doc(alias = "vtkIdList")] pub fn new() -> Self { unsafe extern "C" { fn vtkIdList_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIdList_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIdList_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIdList_get_ptr(self.0) } + Self(unsafe { vtkIdList_new() }) } } impl std::default::Default for vtkIdList { @@ -1362,12 +12819,8 @@ impl Drop for vtkIdList { #[test] fn test_vtkIdList_create_drop() { let obj = vtkIdList::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIdList(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain an ordered list of IdList objects /// @@ -1377,22 +12830,13 @@ fn test_vtkIdList_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIdListCollection(*mut core::ffi::c_void); impl vtkIdListCollection { - /// Creates a new [vtkIdListCollection] wrapped inside `vtkNew` + /// Creates a new [vtkIdListCollection] via `vtkIdListCollection::New()` #[doc(alias = "vtkIdListCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkIdListCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIdListCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIdListCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIdListCollection_get_ptr(self.0) } + Self(unsafe { vtkIdListCollection_new() }) } } impl std::default::Default for vtkIdListCollection { @@ -1412,12 +12856,8 @@ impl Drop for vtkIdListCollection { #[test] fn test_vtkIdListCollection_create_drop() { let obj = vtkIdListCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIdListCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of vtkIdType /// @@ -1428,22 +12868,13 @@ fn test_vtkIdListCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIdTypeArray(*mut core::ffi::c_void); impl vtkIdTypeArray { - /// Creates a new [vtkIdTypeArray] wrapped inside `vtkNew` + /// Creates a new [vtkIdTypeArray] via `vtkIdTypeArray::New()` #[doc(alias = "vtkIdTypeArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkIdTypeArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIdTypeArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIdTypeArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIdTypeArray_get_ptr(self.0) } + Self(unsafe { vtkIdTypeArray_new() }) } } impl std::default::Default for vtkIdTypeArray { @@ -1463,12 +12894,8 @@ impl Drop for vtkIdTypeArray { #[test] fn test_vtkIdTypeArray_create_drop() { let obj = vtkIdTypeArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIdTypeArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Store vtkAlgorithm input/output information. /// @@ -1483,22 +12910,13 @@ fn test_vtkIdTypeArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInformation(*mut core::ffi::c_void); impl vtkInformation { - /// Creates a new [vtkInformation] wrapped inside `vtkNew` + /// Creates a new [vtkInformation] via `vtkInformation::New()` #[doc(alias = "vtkInformation")] pub fn new() -> Self { unsafe extern "C" { fn vtkInformation_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInformation_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInformation_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInformation_get_ptr(self.0) } + Self(unsafe { vtkInformation_new() }) } } impl std::default::Default for vtkInformation { @@ -1518,12 +12936,8 @@ impl Drop for vtkInformation { #[test] fn test_vtkInformation_create_drop() { let obj = vtkInformation::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInformation(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates over keys of an information object /// @@ -1537,22 +12951,13 @@ fn test_vtkInformation_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInformationIterator(*mut core::ffi::c_void); impl vtkInformationIterator { - /// Creates a new [vtkInformationIterator] wrapped inside `vtkNew` + /// Creates a new [vtkInformationIterator] via `vtkInformationIterator::New()` #[doc(alias = "vtkInformationIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkInformationIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInformationIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInformationIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInformationIterator_get_ptr(self.0) } + Self(unsafe { vtkInformationIterator_new() }) } } impl std::default::Default for vtkInformationIterator { @@ -1572,12 +12977,8 @@ impl Drop for vtkInformationIterator { #[test] fn test_vtkInformationIterator_create_drop() { let obj = vtkInformationIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInformationIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Find vtkInformationKeys from name and /// @@ -1585,22 +12986,13 @@ fn test_vtkInformationIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInformationKeyLookup(*mut core::ffi::c_void); impl vtkInformationKeyLookup { - /// Creates a new [vtkInformationKeyLookup] wrapped inside `vtkNew` + /// Creates a new [vtkInformationKeyLookup] via `vtkInformationKeyLookup::New()` #[doc(alias = "vtkInformationKeyLookup")] - pub fn new() -> Self { - unsafe extern "C" { - fn vtkInformationKeyLookup_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkInformationKeyLookup_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { + pub fn new() -> Self { unsafe extern "C" { - fn vtkInformationKeyLookup_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + fn vtkInformationKeyLookup_new() -> *mut core::ffi::c_void; } - unsafe { vtkInformationKeyLookup_get_ptr(self.0) } + Self(unsafe { vtkInformationKeyLookup_new() }) } } impl std::default::Default for vtkInformationKeyLookup { @@ -1620,12 +13012,8 @@ impl Drop for vtkInformationKeyLookup { #[test] fn test_vtkInformationKeyLookup_create_drop() { let obj = vtkInformationKeyLookup::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInformationKeyLookup(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Store zero or more vtkInformation instances. /// @@ -1638,22 +13026,13 @@ fn test_vtkInformationKeyLookup_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInformationVector(*mut core::ffi::c_void); impl vtkInformationVector { - /// Creates a new [vtkInformationVector] wrapped inside `vtkNew` + /// Creates a new [vtkInformationVector] via `vtkInformationVector::New()` #[doc(alias = "vtkInformationVector")] pub fn new() -> Self { unsafe extern "C" { fn vtkInformationVector_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInformationVector_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInformationVector_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInformationVector_get_ptr(self.0) } + Self(unsafe { vtkInformationVector_new() }) } } impl std::default::Default for vtkInformationVector { @@ -1673,12 +13052,8 @@ impl Drop for vtkInformationVector { #[test] fn test_vtkInformationVector_create_drop() { let obj = vtkInformationVector::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInformationVector(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of int /// @@ -1693,22 +13068,13 @@ fn test_vtkInformationVector_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIntArray(*mut core::ffi::c_void); impl vtkIntArray { - /// Creates a new [vtkIntArray] wrapped inside `vtkNew` + /// Creates a new [vtkIntArray] via `vtkIntArray::New()` #[doc(alias = "vtkIntArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkIntArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIntArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIntArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIntArray_get_ptr(self.0) } + Self(unsafe { vtkIntArray_new() }) } } impl std::default::Default for vtkIntArray { @@ -1728,12 +13094,8 @@ impl Drop for vtkIntArray { #[test] fn test_vtkIntArray_create_drop() { let obj = vtkIntArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIntArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of long /// @@ -1749,22 +13111,13 @@ fn test_vtkIntArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLongArray(*mut core::ffi::c_void); impl vtkLongArray { - /// Creates a new [vtkLongArray] wrapped inside `vtkNew` + /// Creates a new [vtkLongArray] via `vtkLongArray::New()` #[doc(alias = "vtkLongArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkLongArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLongArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLongArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLongArray_get_ptr(self.0) } + Self(unsafe { vtkLongArray_new() }) } } impl std::default::Default for vtkLongArray { @@ -1784,12 +13137,8 @@ impl Drop for vtkLongArray { #[test] fn test_vtkLongArray_create_drop() { let obj = vtkLongArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLongArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of long long /// @@ -1804,22 +13153,13 @@ fn test_vtkLongArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLongLongArray(*mut core::ffi::c_void); impl vtkLongLongArray { - /// Creates a new [vtkLongLongArray] wrapped inside `vtkNew` + /// Creates a new [vtkLongLongArray] via `vtkLongLongArray::New()` #[doc(alias = "vtkLongLongArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkLongLongArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLongLongArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLongLongArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLongLongArray_get_ptr(self.0) } + Self(unsafe { vtkLongLongArray_new() }) } } impl std::default::Default for vtkLongLongArray { @@ -1839,12 +13179,8 @@ impl Drop for vtkLongLongArray { #[test] fn test_vtkLongLongArray_create_drop() { let obj = vtkLongLongArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLongLongArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// map scalar values into colors via a lookup table /// @@ -1885,22 +13221,13 @@ fn test_vtkLongLongArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLookupTable(*mut core::ffi::c_void); impl vtkLookupTable { - /// Creates a new [vtkLookupTable] wrapped inside `vtkNew` + /// Creates a new [vtkLookupTable] via `vtkLookupTable::New()` #[doc(alias = "vtkLookupTable")] pub fn new() -> Self { unsafe extern "C" { fn vtkLookupTable_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLookupTable_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLookupTable_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLookupTable_get_ptr(self.0) } + Self(unsafe { vtkLookupTable_new() }) } } impl std::default::Default for vtkLookupTable { @@ -1920,12 +13247,8 @@ impl Drop for vtkLookupTable { #[test] fn test_vtkLookupTable_create_drop() { let obj = vtkLookupTable::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLookupTable(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// performs common math operations /// @@ -1941,20 +13264,13 @@ fn test_vtkLookupTable_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMath(*mut core::ffi::c_void); impl vtkMath { - /// Creates a new [vtkMath] wrapped inside `vtkNew` + /// Creates a new [vtkMath] via `vtkMath::New()` #[doc(alias = "vtkMath")] pub fn new() -> Self { unsafe extern "C" { fn vtkMath_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMath_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMath_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkMath_get_ptr(self.0) } + Self(unsafe { vtkMath_new() }) } } impl std::default::Default for vtkMath { @@ -1974,12 +13290,8 @@ impl Drop for vtkMath { #[test] fn test_vtkMath_create_drop() { let obj = vtkMath::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMath(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generator for Mersenne Twister pseudorandom numbers /// @@ -2005,22 +13317,13 @@ fn test_vtkMath_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMersenneTwister(*mut core::ffi::c_void); impl vtkMersenneTwister { - /// Creates a new [vtkMersenneTwister] wrapped inside `vtkNew` + /// Creates a new [vtkMersenneTwister] via `vtkMersenneTwister::New()` #[doc(alias = "vtkMersenneTwister")] pub fn new() -> Self { unsafe extern "C" { fn vtkMersenneTwister_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMersenneTwister_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMersenneTwister_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMersenneTwister_get_ptr(self.0) } + Self(unsafe { vtkMersenneTwister_new() }) } } impl std::default::Default for vtkMersenneTwister { @@ -2040,12 +13343,8 @@ impl Drop for vtkMersenneTwister { #[test] fn test_vtkMersenneTwister_create_drop() { let obj = vtkMersenneTwister::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMersenneTwister(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Park and Miller Sequence of pseudo random numbers /// @@ -2068,22 +13367,13 @@ fn test_vtkMersenneTwister_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMinimalStandardRandomSequence(*mut core::ffi::c_void); impl vtkMinimalStandardRandomSequence { - /// Creates a new [vtkMinimalStandardRandomSequence] wrapped inside `vtkNew` + /// Creates a new [vtkMinimalStandardRandomSequence] via `vtkMinimalStandardRandomSequence::New()` #[doc(alias = "vtkMinimalStandardRandomSequence")] pub fn new() -> Self { unsafe extern "C" { fn vtkMinimalStandardRandomSequence_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMinimalStandardRandomSequence_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMinimalStandardRandomSequence_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMinimalStandardRandomSequence_get_ptr(self.0) } + Self(unsafe { vtkMinimalStandardRandomSequence_new() }) } } impl std::default::Default for vtkMinimalStandardRandomSequence { @@ -2105,12 +13395,8 @@ impl Drop for vtkMinimalStandardRandomSequence { #[test] fn test_vtkMinimalStandardRandomSequence_create_drop() { let obj = vtkMinimalStandardRandomSequence::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMinimalStandardRandomSequence(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A class for performing multithreaded execution /// @@ -2122,22 +13408,13 @@ fn test_vtkMinimalStandardRandomSequence_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiThreader(*mut core::ffi::c_void); impl vtkMultiThreader { - /// Creates a new [vtkMultiThreader] wrapped inside `vtkNew` + /// Creates a new [vtkMultiThreader] via `vtkMultiThreader::New()` #[doc(alias = "vtkMultiThreader")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiThreader_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiThreader_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiThreader_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiThreader_get_ptr(self.0) } + Self(unsafe { vtkMultiThreader_new() }) } } impl std::default::Default for vtkMultiThreader { @@ -2157,12 +13434,8 @@ impl Drop for vtkMultiThreader { #[test] fn test_vtkMultiThreader_create_drop() { let obj = vtkMultiThreader::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiThreader(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// abstract base class for most VTK objects /// @@ -2190,22 +13463,13 @@ fn test_vtkMultiThreader_create_drop() { #[allow(non_camel_case_types)] pub struct vtkObject(*mut core::ffi::c_void); impl vtkObject { - /// Creates a new [vtkObject] wrapped inside `vtkNew` + /// Creates a new [vtkObject] via `vtkObject::New()` #[doc(alias = "vtkObject")] pub fn new() -> Self { unsafe extern "C" { fn vtkObject_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkObject_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkObject_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkObject_get_ptr(self.0) } + Self(unsafe { vtkObject_new() }) } } impl std::default::Default for vtkObject { @@ -2225,12 +13489,8 @@ impl Drop for vtkObject { #[test] fn test_vtkObject_create_drop() { let obj = vtkObject::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkObject(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of object factories /// @@ -2243,22 +13503,13 @@ fn test_vtkObject_create_drop() { #[allow(non_camel_case_types)] pub struct vtkObjectFactoryCollection(*mut core::ffi::c_void); impl vtkObjectFactoryCollection { - /// Creates a new [vtkObjectFactoryCollection] wrapped inside `vtkNew` + /// Creates a new [vtkObjectFactoryCollection] via `vtkObjectFactoryCollection::New()` #[doc(alias = "vtkObjectFactoryCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkObjectFactoryCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkObjectFactoryCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkObjectFactoryCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkObjectFactoryCollection_get_ptr(self.0) } + Self(unsafe { vtkObjectFactoryCollection_new() }) } } impl std::default::Default for vtkObjectFactoryCollection { @@ -2278,12 +13529,8 @@ impl Drop for vtkObjectFactoryCollection { #[test] fn test_vtkObjectFactoryCollection_create_drop() { let obj = vtkObjectFactoryCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkObjectFactoryCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// supports legacy function callbacks for VTK /// @@ -2304,22 +13551,13 @@ fn test_vtkObjectFactoryCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOldStyleCallbackCommand(*mut core::ffi::c_void); impl vtkOldStyleCallbackCommand { - /// Creates a new [vtkOldStyleCallbackCommand] wrapped inside `vtkNew` + /// Creates a new [vtkOldStyleCallbackCommand] via `vtkOldStyleCallbackCommand::New()` #[doc(alias = "vtkOldStyleCallbackCommand")] pub fn new() -> Self { unsafe extern "C" { fn vtkOldStyleCallbackCommand_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOldStyleCallbackCommand_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOldStyleCallbackCommand_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOldStyleCallbackCommand_get_ptr(self.0) } + Self(unsafe { vtkOldStyleCallbackCommand_new() }) } } impl std::default::Default for vtkOldStyleCallbackCommand { @@ -2339,12 +13577,8 @@ impl Drop for vtkOldStyleCallbackCommand { #[test] fn test_vtkOldStyleCallbackCommand_create_drop() { let obj = vtkOldStyleCallbackCommand::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOldStyleCallbackCommand(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// base class for writing debug output to a console /// @@ -2356,22 +13590,13 @@ fn test_vtkOldStyleCallbackCommand_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOutputWindow(*mut core::ffi::c_void); impl vtkOutputWindow { - /// Creates a new [vtkOutputWindow] wrapped inside `vtkNew` + /// Creates a new [vtkOutputWindow] via `vtkOutputWindow::New()` #[doc(alias = "vtkOutputWindow")] pub fn new() -> Self { unsafe extern "C" { fn vtkOutputWindow_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOutputWindow_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOutputWindow_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOutputWindow_get_ptr(self.0) } + Self(unsafe { vtkOutputWindow_new() }) } } impl std::default::Default for vtkOutputWindow { @@ -2391,12 +13616,8 @@ impl Drop for vtkOutputWindow { #[test] fn test_vtkOutputWindow_create_drop() { let obj = vtkOutputWindow::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOutputWindow(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of override information objects /// @@ -2408,22 +13629,13 @@ fn test_vtkOutputWindow_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOverrideInformationCollection(*mut core::ffi::c_void); impl vtkOverrideInformationCollection { - /// Creates a new [vtkOverrideInformationCollection] wrapped inside `vtkNew` + /// Creates a new [vtkOverrideInformationCollection] via `vtkOverrideInformationCollection::New()` #[doc(alias = "vtkOverrideInformationCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkOverrideInformationCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOverrideInformationCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOverrideInformationCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOverrideInformationCollection_get_ptr(self.0) } + Self(unsafe { vtkOverrideInformationCollection_new() }) } } impl std::default::Default for vtkOverrideInformationCollection { @@ -2445,12 +13657,8 @@ impl Drop for vtkOverrideInformationCollection { #[test] fn test_vtkOverrideInformationCollection_create_drop() { let obj = vtkOverrideInformationCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOverrideInformationCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate 3D points /// @@ -2460,22 +13668,13 @@ fn test_vtkOverrideInformationCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPoints(*mut core::ffi::c_void); impl vtkPoints { - /// Creates a new [vtkPoints] wrapped inside `vtkNew` + /// Creates a new [vtkPoints] via `vtkPoints::New()` #[doc(alias = "vtkPoints")] pub fn new() -> Self { unsafe extern "C" { fn vtkPoints_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPoints_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPoints_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPoints_get_ptr(self.0) } + Self(unsafe { vtkPoints_new() }) } } impl std::default::Default for vtkPoints { @@ -2495,12 +13694,8 @@ impl Drop for vtkPoints { #[test] fn test_vtkPoints_create_drop() { let obj = vtkPoints::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPoints(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate 2D points /// @@ -2510,22 +13705,13 @@ fn test_vtkPoints_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPoints2D(*mut core::ffi::c_void); impl vtkPoints2D { - /// Creates a new [vtkPoints2D] wrapped inside `vtkNew` + /// Creates a new [vtkPoints2D] via `vtkPoints2D::New()` #[doc(alias = "vtkPoints2D")] pub fn new() -> Self { unsafe extern "C" { fn vtkPoints2D_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPoints2D_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPoints2D_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPoints2D_get_ptr(self.0) } + Self(unsafe { vtkPoints2D_new() }) } } impl std::default::Default for vtkPoints2D { @@ -2545,12 +13731,8 @@ impl Drop for vtkPoints2D { #[test] fn test_vtkPoints2D_create_drop() { let obj = vtkPoints2D::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPoints2D(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a list of ids arranged in priority order /// @@ -2575,22 +13757,13 @@ fn test_vtkPoints2D_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPriorityQueue(*mut core::ffi::c_void); impl vtkPriorityQueue { - /// Creates a new [vtkPriorityQueue] wrapped inside `vtkNew` + /// Creates a new [vtkPriorityQueue] via `vtkPriorityQueue::New()` #[doc(alias = "vtkPriorityQueue")] pub fn new() -> Self { unsafe extern "C" { fn vtkPriorityQueue_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPriorityQueue_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPriorityQueue_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPriorityQueue_get_ptr(self.0) } + Self(unsafe { vtkPriorityQueue_new() }) } } impl std::default::Default for vtkPriorityQueue { @@ -2610,12 +13783,8 @@ impl Drop for vtkPriorityQueue { #[test] fn test_vtkPriorityQueue_create_drop() { let obj = vtkPriorityQueue::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPriorityQueue(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// convenience class to quickly generate a pool of random numbers /// @@ -2641,22 +13810,13 @@ fn test_vtkPriorityQueue_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRandomPool(*mut core::ffi::c_void); impl vtkRandomPool { - /// Creates a new [vtkRandomPool] wrapped inside `vtkNew` + /// Creates a new [vtkRandomPool] via `vtkRandomPool::New()` #[doc(alias = "vtkRandomPool")] pub fn new() -> Self { unsafe extern "C" { fn vtkRandomPool_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRandomPool_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRandomPool_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRandomPool_get_ptr(self.0) } + Self(unsafe { vtkRandomPool_new() }) } } impl std::default::Default for vtkRandomPool { @@ -2676,12 +13836,8 @@ impl Drop for vtkRandomPool { #[test] fn test_vtkRandomPool_create_drop() { let obj = vtkRandomPool::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRandomPool(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Obsolete / empty subclass of object. /// @@ -2692,22 +13848,13 @@ fn test_vtkRandomPool_create_drop() { #[allow(non_camel_case_types)] pub struct vtkReferenceCount(*mut core::ffi::c_void); impl vtkReferenceCount { - /// Creates a new [vtkReferenceCount] wrapped inside `vtkNew` + /// Creates a new [vtkReferenceCount] via `vtkReferenceCount::New()` #[doc(alias = "vtkReferenceCount")] pub fn new() -> Self { unsafe extern "C" { fn vtkReferenceCount_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkReferenceCount_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkReferenceCount_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkReferenceCount_get_ptr(self.0) } + Self(unsafe { vtkReferenceCount_new() }) } } impl std::default::Default for vtkReferenceCount { @@ -2727,12 +13874,8 @@ impl Drop for vtkReferenceCount { #[test] fn test_vtkReferenceCount_create_drop() { let obj = vtkReferenceCount::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkReferenceCount(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for mapping scalar values to colors /// @@ -2765,22 +13908,13 @@ fn test_vtkReferenceCount_create_drop() { #[allow(non_camel_case_types)] pub struct vtkScalarsToColors(*mut core::ffi::c_void); impl vtkScalarsToColors { - /// Creates a new [vtkScalarsToColors] wrapped inside `vtkNew` + /// Creates a new [vtkScalarsToColors] via `vtkScalarsToColors::New()` #[doc(alias = "vtkScalarsToColors")] pub fn new() -> Self { unsafe extern "C" { fn vtkScalarsToColors_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkScalarsToColors_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkScalarsToColors_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkScalarsToColors_get_ptr(self.0) } + Self(unsafe { vtkScalarsToColors_new() }) } } impl std::default::Default for vtkScalarsToColors { @@ -2800,12 +13934,8 @@ impl Drop for vtkScalarsToColors { #[test] fn test_vtkScalarsToColors_create_drop() { let obj = vtkScalarsToColors::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkScalarsToColors(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of short /// @@ -2820,22 +13950,13 @@ fn test_vtkScalarsToColors_create_drop() { #[allow(non_camel_case_types)] pub struct vtkShortArray(*mut core::ffi::c_void); impl vtkShortArray { - /// Creates a new [vtkShortArray] wrapped inside `vtkNew` + /// Creates a new [vtkShortArray] via `vtkShortArray::New()` #[doc(alias = "vtkShortArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkShortArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkShortArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkShortArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkShortArray_get_ptr(self.0) } + Self(unsafe { vtkShortArray_new() }) } } impl std::default::Default for vtkShortArray { @@ -2855,12 +13976,8 @@ impl Drop for vtkShortArray { #[test] fn test_vtkShortArray_create_drop() { let obj = vtkShortArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkShortArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of signed char /// @@ -2871,22 +13988,13 @@ fn test_vtkShortArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSignedCharArray(*mut core::ffi::c_void); impl vtkSignedCharArray { - /// Creates a new [vtkSignedCharArray] wrapped inside `vtkNew` + /// Creates a new [vtkSignedCharArray] via `vtkSignedCharArray::New()` #[doc(alias = "vtkSignedCharArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkSignedCharArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSignedCharArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSignedCharArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSignedCharArray_get_ptr(self.0) } + Self(unsafe { vtkSignedCharArray_new() }) } } impl std::default::Default for vtkSignedCharArray { @@ -2906,12 +14014,8 @@ impl Drop for vtkSignedCharArray { #[test] fn test_vtkSignedCharArray_create_drop() { let obj = vtkSignedCharArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSignedCharArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// provides several methods for sorting VTK arrays. /// @@ -2954,22 +14058,13 @@ fn test_vtkSignedCharArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSortDataArray(*mut core::ffi::c_void); impl vtkSortDataArray { - /// Creates a new [vtkSortDataArray] wrapped inside `vtkNew` + /// Creates a new [vtkSortDataArray] via `vtkSortDataArray::New()` #[doc(alias = "vtkSortDataArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkSortDataArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSortDataArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSortDataArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSortDataArray_get_ptr(self.0) } + Self(unsafe { vtkSortDataArray_new() }) } } impl std::default::Default for vtkSortDataArray { @@ -2989,12 +14084,8 @@ impl Drop for vtkSortDataArray { #[test] fn test_vtkSortDataArray_create_drop() { let obj = vtkSortDataArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSortDataArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a vtkAbstractArray subclass for strings /// @@ -3007,22 +14098,13 @@ fn test_vtkSortDataArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStringArray(*mut core::ffi::c_void); impl vtkStringArray { - /// Creates a new [vtkStringArray] wrapped inside `vtkNew` + /// Creates a new [vtkStringArray] via `vtkStringArray::New()` #[doc(alias = "vtkStringArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkStringArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStringArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStringArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStringArray_get_ptr(self.0) } + Self(unsafe { vtkStringArray_new() }) } } impl std::default::Default for vtkStringArray { @@ -3042,12 +14124,8 @@ impl Drop for vtkStringArray { #[test] fn test_vtkStringArray_create_drop() { let obj = vtkStringArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStringArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// File Specific output window class /// @@ -3057,22 +14135,13 @@ fn test_vtkStringArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStringOutputWindow(*mut core::ffi::c_void); impl vtkStringOutputWindow { - /// Creates a new [vtkStringOutputWindow] wrapped inside `vtkNew` + /// Creates a new [vtkStringOutputWindow] via `vtkStringOutputWindow::New()` #[doc(alias = "vtkStringOutputWindow")] pub fn new() -> Self { unsafe extern "C" { fn vtkStringOutputWindow_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStringOutputWindow_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStringOutputWindow_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStringOutputWindow_get_ptr(self.0) } + Self(unsafe { vtkStringOutputWindow_new() }) } } impl std::default::Default for vtkStringOutputWindow { @@ -3092,12 +14161,8 @@ impl Drop for vtkStringOutputWindow { #[test] fn test_vtkStringOutputWindow_create_drop() { let obj = vtkStringOutputWindow::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStringOutputWindow(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// performs common time operations /// @@ -3107,22 +14172,13 @@ fn test_vtkStringOutputWindow_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTimePointUtility(*mut core::ffi::c_void); impl vtkTimePointUtility { - /// Creates a new [vtkTimePointUtility] wrapped inside `vtkNew` + /// Creates a new [vtkTimePointUtility] via `vtkTimePointUtility::New()` #[doc(alias = "vtkTimePointUtility")] pub fn new() -> Self { unsafe extern "C" { fn vtkTimePointUtility_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTimePointUtility_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTimePointUtility_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTimePointUtility_get_ptr(self.0) } + Self(unsafe { vtkTimePointUtility_new() }) } } impl std::default::Default for vtkTimePointUtility { @@ -3142,33 +14198,20 @@ impl Drop for vtkTimePointUtility { #[test] fn test_vtkTimePointUtility_create_drop() { let obj = vtkTimePointUtility::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTimePointUtility(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeFloat32Array(*mut core::ffi::c_void); impl vtkTypeFloat32Array { - /// Creates a new [vtkTypeFloat32Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeFloat32Array] via `vtkTypeFloat32Array::New()` #[doc(alias = "vtkTypeFloat32Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeFloat32Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeFloat32Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeFloat32Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeFloat32Array_get_ptr(self.0) } + Self(unsafe { vtkTypeFloat32Array_new() }) } } impl std::default::Default for vtkTypeFloat32Array { @@ -3188,33 +14231,20 @@ impl Drop for vtkTypeFloat32Array { #[test] fn test_vtkTypeFloat32Array_create_drop() { let obj = vtkTypeFloat32Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeFloat32Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeFloat64Array(*mut core::ffi::c_void); impl vtkTypeFloat64Array { - /// Creates a new [vtkTypeFloat64Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeFloat64Array] via `vtkTypeFloat64Array::New()` #[doc(alias = "vtkTypeFloat64Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeFloat64Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeFloat64Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeFloat64Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeFloat64Array_get_ptr(self.0) } + Self(unsafe { vtkTypeFloat64Array_new() }) } } impl std::default::Default for vtkTypeFloat64Array { @@ -3234,33 +14264,20 @@ impl Drop for vtkTypeFloat64Array { #[test] fn test_vtkTypeFloat64Array_create_drop() { let obj = vtkTypeFloat64Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeFloat64Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeInt16Array(*mut core::ffi::c_void); impl vtkTypeInt16Array { - /// Creates a new [vtkTypeInt16Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeInt16Array] via `vtkTypeInt16Array::New()` #[doc(alias = "vtkTypeInt16Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeInt16Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeInt16Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeInt16Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeInt16Array_get_ptr(self.0) } + Self(unsafe { vtkTypeInt16Array_new() }) } } impl std::default::Default for vtkTypeInt16Array { @@ -3280,33 +14297,20 @@ impl Drop for vtkTypeInt16Array { #[test] fn test_vtkTypeInt16Array_create_drop() { let obj = vtkTypeInt16Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeInt16Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeInt32Array(*mut core::ffi::c_void); impl vtkTypeInt32Array { - /// Creates a new [vtkTypeInt32Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeInt32Array] via `vtkTypeInt32Array::New()` #[doc(alias = "vtkTypeInt32Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeInt32Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeInt32Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeInt32Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeInt32Array_get_ptr(self.0) } + Self(unsafe { vtkTypeInt32Array_new() }) } } impl std::default::Default for vtkTypeInt32Array { @@ -3326,33 +14330,20 @@ impl Drop for vtkTypeInt32Array { #[test] fn test_vtkTypeInt32Array_create_drop() { let obj = vtkTypeInt32Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeInt32Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeInt64Array(*mut core::ffi::c_void); impl vtkTypeInt64Array { - /// Creates a new [vtkTypeInt64Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeInt64Array] via `vtkTypeInt64Array::New()` #[doc(alias = "vtkTypeInt64Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeInt64Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeInt64Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeInt64Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeInt64Array_get_ptr(self.0) } + Self(unsafe { vtkTypeInt64Array_new() }) } } impl std::default::Default for vtkTypeInt64Array { @@ -3372,33 +14363,20 @@ impl Drop for vtkTypeInt64Array { #[test] fn test_vtkTypeInt64Array_create_drop() { let obj = vtkTypeInt64Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeInt64Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeInt8Array(*mut core::ffi::c_void); impl vtkTypeInt8Array { - /// Creates a new [vtkTypeInt8Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeInt8Array] via `vtkTypeInt8Array::New()` #[doc(alias = "vtkTypeInt8Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeInt8Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeInt8Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeInt8Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeInt8Array_get_ptr(self.0) } + Self(unsafe { vtkTypeInt8Array_new() }) } } impl std::default::Default for vtkTypeInt8Array { @@ -3418,33 +14396,20 @@ impl Drop for vtkTypeInt8Array { #[test] fn test_vtkTypeInt8Array_create_drop() { let obj = vtkTypeInt8Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeInt8Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeUInt16Array(*mut core::ffi::c_void); impl vtkTypeUInt16Array { - /// Creates a new [vtkTypeUInt16Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeUInt16Array] via `vtkTypeUInt16Array::New()` #[doc(alias = "vtkTypeUInt16Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeUInt16Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeUInt16Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeUInt16Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeUInt16Array_get_ptr(self.0) } + Self(unsafe { vtkTypeUInt16Array_new() }) } } impl std::default::Default for vtkTypeUInt16Array { @@ -3464,33 +14429,20 @@ impl Drop for vtkTypeUInt16Array { #[test] fn test_vtkTypeUInt16Array_create_drop() { let obj = vtkTypeUInt16Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeUInt16Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeUInt32Array(*mut core::ffi::c_void); impl vtkTypeUInt32Array { - /// Creates a new [vtkTypeUInt32Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeUInt32Array] via `vtkTypeUInt32Array::New()` #[doc(alias = "vtkTypeUInt32Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeUInt32Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeUInt32Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeUInt32Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeUInt32Array_get_ptr(self.0) } + Self(unsafe { vtkTypeUInt32Array_new() }) } } impl std::default::Default for vtkTypeUInt32Array { @@ -3510,33 +14462,20 @@ impl Drop for vtkTypeUInt32Array { #[test] fn test_vtkTypeUInt32Array_create_drop() { let obj = vtkTypeUInt32Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeUInt32Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeUInt64Array(*mut core::ffi::c_void); impl vtkTypeUInt64Array { - /// Creates a new [vtkTypeUInt64Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeUInt64Array] via `vtkTypeUInt64Array::New()` #[doc(alias = "vtkTypeUInt64Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeUInt64Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeUInt64Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeUInt64Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeUInt64Array_get_ptr(self.0) } + Self(unsafe { vtkTypeUInt64Array_new() }) } } impl std::default::Default for vtkTypeUInt64Array { @@ -3556,33 +14495,20 @@ impl Drop for vtkTypeUInt64Array { #[test] fn test_vtkTypeUInt64Array_create_drop() { let obj = vtkTypeUInt64Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeUInt64Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkTypeUInt8Array(*mut core::ffi::c_void); impl vtkTypeUInt8Array { - /// Creates a new [vtkTypeUInt8Array] wrapped inside `vtkNew` + /// Creates a new [vtkTypeUInt8Array] via `vtkTypeUInt8Array::New()` #[doc(alias = "vtkTypeUInt8Array")] pub fn new() -> Self { unsafe extern "C" { fn vtkTypeUInt8Array_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTypeUInt8Array_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTypeUInt8Array_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTypeUInt8Array_get_ptr(self.0) } + Self(unsafe { vtkTypeUInt8Array_new() }) } } impl std::default::Default for vtkTypeUInt8Array { @@ -3602,12 +14528,47 @@ impl Drop for vtkTypeUInt8Array { #[test] fn test_vtkTypeUInt8Array_create_drop() { let obj = vtkTypeUInt8Array::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Subclass of vtkAbstractArray that holds vtkUnicodeStrings +/// +/// +/// +/// +/// @par Thanks: +/// Developed by Timothy M. Shead (tshead@sandia.gov) at Sandia National Laboratories. +#[allow(non_camel_case_types)] +pub struct vtkUnicodeStringArray(*mut core::ffi::c_void); +impl vtkUnicodeStringArray { + /// Creates a new [vtkUnicodeStringArray] via `vtkUnicodeStringArray::New()` + #[doc(alias = "vtkUnicodeStringArray")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkUnicodeStringArray_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkUnicodeStringArray_new() }) + } +} +impl std::default::Default for vtkUnicodeStringArray { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkUnicodeStringArray { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkUnicodeStringArray_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkUnicodeStringArray_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkUnicodeStringArray_create_drop() { + let obj = vtkUnicodeStringArray::new(); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTypeUInt8Array(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned char /// @@ -3618,22 +14579,13 @@ fn test_vtkTypeUInt8Array_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedCharArray(*mut core::ffi::c_void); impl vtkUnsignedCharArray { - /// Creates a new [vtkUnsignedCharArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedCharArray] via `vtkUnsignedCharArray::New()` #[doc(alias = "vtkUnsignedCharArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedCharArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedCharArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedCharArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedCharArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedCharArray_new() }) } } impl std::default::Default for vtkUnsignedCharArray { @@ -3653,12 +14605,8 @@ impl Drop for vtkUnsignedCharArray { #[test] fn test_vtkUnsignedCharArray_create_drop() { let obj = vtkUnsignedCharArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedCharArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned int /// @@ -3673,22 +14621,13 @@ fn test_vtkUnsignedCharArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedIntArray(*mut core::ffi::c_void); impl vtkUnsignedIntArray { - /// Creates a new [vtkUnsignedIntArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedIntArray] via `vtkUnsignedIntArray::New()` #[doc(alias = "vtkUnsignedIntArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedIntArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedIntArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedIntArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedIntArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedIntArray_new() }) } } impl std::default::Default for vtkUnsignedIntArray { @@ -3708,12 +14647,8 @@ impl Drop for vtkUnsignedIntArray { #[test] fn test_vtkUnsignedIntArray_create_drop() { let obj = vtkUnsignedIntArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedIntArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned long /// @@ -3730,22 +14665,13 @@ fn test_vtkUnsignedIntArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedLongArray(*mut core::ffi::c_void); impl vtkUnsignedLongArray { - /// Creates a new [vtkUnsignedLongArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedLongArray] via `vtkUnsignedLongArray::New()` #[doc(alias = "vtkUnsignedLongArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedLongArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedLongArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedLongArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedLongArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedLongArray_new() }) } } impl std::default::Default for vtkUnsignedLongArray { @@ -3765,12 +14691,8 @@ impl Drop for vtkUnsignedLongArray { #[test] fn test_vtkUnsignedLongArray_create_drop() { let obj = vtkUnsignedLongArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedLongArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned long long /// @@ -3785,22 +14707,13 @@ fn test_vtkUnsignedLongArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedLongLongArray(*mut core::ffi::c_void); impl vtkUnsignedLongLongArray { - /// Creates a new [vtkUnsignedLongLongArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedLongLongArray] via `vtkUnsignedLongLongArray::New()` #[doc(alias = "vtkUnsignedLongLongArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedLongLongArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedLongLongArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedLongLongArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedLongLongArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedLongLongArray_new() }) } } impl std::default::Default for vtkUnsignedLongLongArray { @@ -3820,12 +14733,8 @@ impl Drop for vtkUnsignedLongLongArray { #[test] fn test_vtkUnsignedLongLongArray_create_drop() { let obj = vtkUnsignedLongLongArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedLongLongArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of unsigned short /// @@ -3840,22 +14749,13 @@ fn test_vtkUnsignedLongLongArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnsignedShortArray(*mut core::ffi::c_void); impl vtkUnsignedShortArray { - /// Creates a new [vtkUnsignedShortArray] wrapped inside `vtkNew` + /// Creates a new [vtkUnsignedShortArray] via `vtkUnsignedShortArray::New()` #[doc(alias = "vtkUnsignedShortArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnsignedShortArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnsignedShortArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnsignedShortArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnsignedShortArray_get_ptr(self.0) } + Self(unsafe { vtkUnsignedShortArray_new() }) } } impl std::default::Default for vtkUnsignedShortArray { @@ -3875,12 +14775,8 @@ impl Drop for vtkUnsignedShortArray { #[test] fn test_vtkUnsignedShortArray_create_drop() { let obj = vtkUnsignedShortArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnsignedShortArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// An array holding vtkVariants. /// @@ -3893,22 +14789,13 @@ fn test_vtkUnsignedShortArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVariantArray(*mut core::ffi::c_void); impl vtkVariantArray { - /// Creates a new [vtkVariantArray] wrapped inside `vtkNew` + /// Creates a new [vtkVariantArray] via `vtkVariantArray::New()` #[doc(alias = "vtkVariantArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkVariantArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVariantArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVariantArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVariantArray_get_ptr(self.0) } + Self(unsafe { vtkVariantArray_new() }) } } impl std::default::Default for vtkVariantArray { @@ -3928,12 +14815,8 @@ impl Drop for vtkVariantArray { #[test] fn test_vtkVariantArray_create_drop() { let obj = vtkVariantArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVariantArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Versioning class for vtk /// @@ -3947,22 +14830,13 @@ fn test_vtkVariantArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVersion(*mut core::ffi::c_void); impl vtkVersion { - /// Creates a new [vtkVersion] wrapped inside `vtkNew` + /// Creates a new [vtkVersion] via `vtkVersion::New()` #[doc(alias = "vtkVersion")] pub fn new() -> Self { unsafe extern "C" { fn vtkVersion_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVersion_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVersion_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVersion_get_ptr(self.0) } + Self(unsafe { vtkVersion_new() }) } } impl std::default::Default for vtkVersion { @@ -3982,12 +14856,8 @@ impl Drop for vtkVersion { #[test] fn test_vtkVersion_create_drop() { let obj = vtkVersion::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVersion(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dynamic, self-adjusting array of void* pointers /// @@ -3998,22 +14868,13 @@ fn test_vtkVersion_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVoidArray(*mut core::ffi::c_void); impl vtkVoidArray { - /// Creates a new [vtkVoidArray] wrapped inside `vtkNew` + /// Creates a new [vtkVoidArray] via `vtkVoidArray::New()` #[doc(alias = "vtkVoidArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkVoidArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVoidArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVoidArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVoidArray_get_ptr(self.0) } + Self(unsafe { vtkVoidArray_new() }) } } impl std::default::Default for vtkVoidArray { @@ -4033,12 +14894,8 @@ impl Drop for vtkVoidArray { #[test] fn test_vtkVoidArray_create_drop() { let obj = vtkVoidArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVoidArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Utility class to hold a weak reference to a vtkObject. /// @@ -4048,22 +14905,13 @@ fn test_vtkVoidArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkWeakReference(*mut core::ffi::c_void); impl vtkWeakReference { - /// Creates a new [vtkWeakReference] wrapped inside `vtkNew` + /// Creates a new [vtkWeakReference] via `vtkWeakReference::New()` #[doc(alias = "vtkWeakReference")] pub fn new() -> Self { unsafe extern "C" { fn vtkWeakReference_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkWeakReference_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkWeakReference_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkWeakReference_get_ptr(self.0) } + Self(unsafe { vtkWeakReference_new() }) } } impl std::default::Default for vtkWeakReference { @@ -4083,12 +14931,8 @@ impl Drop for vtkWeakReference { #[test] fn test_vtkWeakReference_create_drop() { let obj = vtkWeakReference::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkWeakReference(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// XML File Specific output window class /// @@ -4112,22 +14956,13 @@ fn test_vtkWeakReference_create_drop() { #[allow(non_camel_case_types)] pub struct vtkXMLFileOutputWindow(*mut core::ffi::c_void); impl vtkXMLFileOutputWindow { - /// Creates a new [vtkXMLFileOutputWindow] wrapped inside `vtkNew` + /// Creates a new [vtkXMLFileOutputWindow] via `vtkXMLFileOutputWindow::New()` #[doc(alias = "vtkXMLFileOutputWindow")] pub fn new() -> Self { unsafe extern "C" { fn vtkXMLFileOutputWindow_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkXMLFileOutputWindow_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkXMLFileOutputWindow_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkXMLFileOutputWindow_get_ptr(self.0) } + Self(unsafe { vtkXMLFileOutputWindow_new() }) } } impl std::default::Default for vtkXMLFileOutputWindow { @@ -4147,10 +14982,6 @@ impl Drop for vtkXMLFileOutputWindow { #[test] fn test_vtkXMLFileOutputWindow_create_drop() { let obj = vtkXMLFileOutputWindow::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkXMLFileOutputWindow(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonDataModel.rs b/vtk-rs-9.1/src/vtkCommonDataModel.rs index e802577..92ffc6c 100644 --- a/vtk-rs-9.1/src/vtkCommonDataModel.rs +++ b/vtk-rs-9.1/src/vtkCommonDataModel.rs @@ -1,3 +1,37078 @@ +pub trait VtkAMRBox { + fn invalidate(&mut self) -> (); + fn empty_dimension(&mut self, i: core::ffi::c_int) -> bool; + fn set_dimensions( + &mut self, + ilo: core::ffi::c_int, + jlo: core::ffi::c_int, + klo: core::ffi::c_int, + ihi: core::ffi::c_int, + jhi: core::ffi::c_int, + khi: core::ffi::c_int, + desc: core::ffi::c_int, + ) -> (); + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_number_of_nodes(&mut self) -> core::ffi::c_longlong; + fn compute_dimension(&mut self) -> core::ffi::c_int; + fn empty(&mut self) -> bool; + fn is_invalid(&mut self) -> bool; + fn coarsen(&mut self, r: core::ffi::c_int) -> (); + fn refine(&mut self, r: core::ffi::c_int) -> (); + fn grow(&mut self, byN: core::ffi::c_int) -> (); + fn shrink(&mut self, byN: core::ffi::c_int) -> (); + fn shift( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn contains( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> bool; + fn remove_ghosts(&mut self, r: core::ffi::c_int) -> (); + fn get_bytesize(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkAMRDataInternals { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn insert(&mut self, index: core::ffi::c_uint, grid: *mut core::ffi::c_void) -> (); + fn get_data_set( + &mut self, + compositeIndex: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn empty(&mut self) -> bool; + fn get_number_of_blocks(&mut self) -> core::ffi::c_uint; +} +pub trait VtkAMRInformation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_grid_description(&mut self) -> core::ffi::c_int; + fn set_grid_description(&mut self, description: core::ffi::c_int) -> (); + fn get_number_of_levels(&mut self) -> core::ffi::c_uint; + fn get_number_of_data_sets(&mut self, level: core::ffi::c_uint) -> core::ffi::c_uint; + fn get_total_number_of_blocks(&mut self) -> core::ffi::c_uint; + fn get_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> core::ffi::c_int; + fn compute_index_pair( + &mut self, + index: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + id: &mut core::ffi::c_uint, + ) -> (); + fn has_spacing(&mut self, level: core::ffi::c_uint) -> bool; + fn get_amr_block_source_index( + &mut self, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_amr_block_source_index( + &mut self, + index: core::ffi::c_int, + sourceId: core::ffi::c_int, + ) -> (); + fn generate_refinement_ratio(&mut self) -> (); + fn has_refinement_ratio(&mut self) -> bool; + fn set_refinement_ratio( + &mut self, + level: core::ffi::c_uint, + ratio: core::ffi::c_int, + ) -> (); + fn get_refinement_ratio(&mut self, level: core::ffi::c_uint) -> core::ffi::c_int; + fn has_children_information(&mut self) -> bool; + fn print_parent_child_info( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> (); + fn generate_parent_child_information(&mut self) -> (); + fn audit(&mut self) -> bool; + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); +} +pub trait VtkAMRUtilities { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn strip_ghost_layers( + &mut self, + ghostedAMRData: *mut core::ffi::c_void, + strippedAMRData: *mut core::ffi::c_void, + ) -> (); + fn has_partially_overlapping_ghost_cells( + &mut self, + amr: *mut core::ffi::c_void, + ) -> bool; + fn blank_cells(&mut self, amr: *mut core::ffi::c_void) -> (); +} +pub trait VtkAbstractCellLinks { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn build_links(&mut self, data: *mut core::ffi::c_void) -> (); + fn initialize(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn compute_type( + &mut self, + maxPtId: core::ffi::c_longlong, + maxCellId: core::ffi::c_longlong, + ca: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_type(&mut self) -> core::ffi::c_int; + fn set_sequential_processing(&mut self, _arg: bool) -> (); + fn get_sequential_processing(&mut self) -> bool; + fn sequential_processing_on(&mut self) -> (); + fn sequential_processing_off(&mut self) -> (); +} +pub trait VtkAbstractCellLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_cells_per_node(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_cells_per_node_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_cells_per_node_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_cells_per_node(&mut self) -> core::ffi::c_int; + fn set_cache_cell_bounds(&mut self, _arg: core::ffi::c_int) -> (); + fn get_cache_cell_bounds(&mut self) -> core::ffi::c_int; + fn cache_cell_bounds_on(&mut self) -> (); + fn cache_cell_bounds_off(&mut self) -> (); + fn set_retain_cell_lists(&mut self, _arg: core::ffi::c_int) -> (); + fn get_retain_cell_lists(&mut self) -> core::ffi::c_int; + fn retain_cell_lists_on(&mut self) -> (); + fn retain_cell_lists_off(&mut self) -> (); + fn set_lazy_evaluation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_lazy_evaluation(&mut self) -> core::ffi::c_int; + fn lazy_evaluation_on(&mut self) -> (); + fn lazy_evaluation_off(&mut self) -> (); + fn set_use_existing_search_structure(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_existing_search_structure(&mut self) -> core::ffi::c_int; + fn use_existing_search_structure_on(&mut self) -> (); + fn use_existing_search_structure_off(&mut self) -> (); +} +pub trait VtkAbstractElectronicData { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_number_of_m_os(&mut self) -> core::ffi::c_longlong; + fn get_number_of_electrons(&mut self) -> core::ffi::c_longlong; + fn get_mo(&mut self, orbitalNumber: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_electron_density(&mut self) -> *mut core::ffi::c_void; + fn get_homo(&mut self) -> *mut core::ffi::c_void; + fn get_lumo(&mut self) -> *mut core::ffi::c_void; + fn get_homo_orbital_number(&mut self) -> core::ffi::c_longlong; + fn get_lumo_orbital_number(&mut self) -> core::ffi::c_longlong; + fn is_homo(&mut self, orbitalNumber: core::ffi::c_longlong) -> bool; + fn is_lumo(&mut self, orbitalNumber: core::ffi::c_longlong) -> bool; + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn get_padding(&mut self) -> core::ffi::c_double; +} +pub trait VtkAbstractPointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn find_closest_n_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn find_points_within_radius( + &mut self, + R: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_buckets(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkAdjacentVertexIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> (); + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn get_vertex(&mut self) -> core::ffi::c_longlong; + fn next(&mut self) -> core::ffi::c_longlong; + fn has_next(&mut self) -> bool; +} +pub trait VtkAngularPeriodicDataArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_angle(&mut self, angle: core::ffi::c_double) -> (); + fn get_angle(&mut self) -> core::ffi::c_double; + fn set_axis(&mut self, axis: core::ffi::c_int) -> (); + fn get_axis(&mut self) -> core::ffi::c_int; + fn set_axis_to_x(&mut self) -> (); + fn set_axis_to_y(&mut self) -> (); + fn set_axis_to_z(&mut self) -> (); +} +pub trait VtkAnimationScene { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_play_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn set_mode_to_sequence(&mut self) -> (); + fn set_mode_to_real_time(&mut self) -> (); + fn get_play_mode(&mut self) -> core::ffi::c_int; + fn set_frame_rate(&mut self, _arg: core::ffi::c_double) -> (); + fn get_frame_rate(&mut self) -> core::ffi::c_double; + fn add_cue(&mut self, cue: *mut core::ffi::c_void) -> (); + fn remove_cue(&mut self, cue: *mut core::ffi::c_void) -> (); + fn remove_all_cues(&mut self) -> (); + fn get_number_of_cues(&mut self) -> core::ffi::c_int; + fn play(&mut self) -> (); + fn stop(&mut self) -> (); + fn set_loop(&mut self, _arg: core::ffi::c_int) -> (); + fn get_loop(&mut self) -> core::ffi::c_int; + fn set_animation_time(&mut self, time: core::ffi::c_double) -> (); + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> (); + fn is_in_play(&mut self) -> core::ffi::c_int; +} +pub trait VtkAnnotation { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_selection(&mut self) -> *mut core::ffi::c_void; + fn set_selection(&mut self, selection: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn label(&mut self) -> *mut core::ffi::c_void; + fn color(&mut self) -> *mut core::ffi::c_void; + fn opacity(&mut self) -> *mut core::ffi::c_void; + fn icon_index(&mut self) -> *mut core::ffi::c_void; + fn enable(&mut self) -> *mut core::ffi::c_void; + fn hide(&mut self) -> *mut core::ffi::c_void; + fn data(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkAnnotationLayers { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn set_current_annotation(&mut self, ann: *mut core::ffi::c_void) -> (); + fn get_current_annotation(&mut self) -> *mut core::ffi::c_void; + fn set_current_selection(&mut self, sel: *mut core::ffi::c_void) -> (); + fn get_current_selection(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_annotations(&mut self) -> core::ffi::c_uint; + fn get_annotation(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn add_annotation(&mut self, ann: *mut core::ffi::c_void) -> (); + fn remove_annotation(&mut self, ann: *mut core::ffi::c_void) -> (); + fn initialize(&mut self) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkArrayData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn add_array(&mut self, p0: *mut core::ffi::c_void) -> (); + fn clear_arrays(&mut self) -> (); + fn get_number_of_arrays(&mut self) -> core::ffi::c_longlong; + fn get_array(&mut self, index: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_array_by_name(&mut self, name: &str) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); +} +pub trait VtkAtom { + fn get_id(&mut self) -> core::ffi::c_longlong; + fn get_molecule(&mut self) -> *mut core::ffi::c_void; + fn get_atomic_number(&mut self) -> core::ffi::c_ushort; + fn set_atomic_number(&mut self, atomicNum: core::ffi::c_ushort) -> (); + fn set_position( + &mut self, + x: core::ffi::c_float, + y: core::ffi::c_float, + z: core::ffi::c_float, + ) -> (); +} +pub trait VtkAttributesErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_absolute_attribute_tolerance(&mut self) -> core::ffi::c_double; + fn set_absolute_attribute_tolerance(&mut self, value: core::ffi::c_double) -> (); + fn get_attribute_tolerance(&mut self) -> core::ffi::c_double; + fn set_attribute_tolerance(&mut self, value: core::ffi::c_double) -> (); +} +pub trait VtkBSPCuts { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_kd_node_tree(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_cuts(&mut self) -> core::ffi::c_int; + fn equals( + &mut self, + other: *mut core::ffi::c_void, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + fn print_tree(&mut self) -> (); + fn print_arrays(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); +} +pub trait VtkBSPIntersections { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> (); + fn get_cuts(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_regions(&mut self) -> core::ffi::c_int; + fn intersects_sphere_2( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int; + fn intersects_cell( + &mut self, + regionId: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_compute_intersections_using_data_bounds(&mut self) -> core::ffi::c_int; + fn set_compute_intersections_using_data_bounds(&mut self, c: core::ffi::c_int) -> (); + fn compute_intersections_using_data_bounds_on(&mut self) -> (); + fn compute_intersections_using_data_bounds_off(&mut self) -> (); +} +pub trait VtkBezierCurve { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> (); + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> (); + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierInterpolation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierQuadrilateral { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> (); + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierTetra { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierTriangle { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBezierWedge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> (); + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkBiQuadraticQuad { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkBiQuadraticQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkBiQuadraticQuadraticWedge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkBiQuadraticTriangle { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkBond { + fn get_id(&mut self) -> core::ffi::c_longlong; + fn get_molecule(&mut self) -> *mut core::ffi::c_void; + fn get_begin_atom_id(&mut self) -> core::ffi::c_longlong; + fn get_end_atom_id(&mut self) -> core::ffi::c_longlong; + fn get_order(&mut self) -> core::ffi::c_ushort; + fn get_length(&mut self) -> core::ffi::c_double; +} +pub trait VtkBoundingBox { + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn compute_bounds(&mut self, pts: *mut core::ffi::c_void) -> (); + fn set_min_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_max_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn is_valid(&mut self) -> core::ffi::c_int; + fn add_point( + &mut self, + px: core::ffi::c_double, + py: core::ffi::c_double, + pz: core::ffi::c_double, + ) -> (); + fn compute_inner_dimension(&mut self) -> core::ffi::c_int; + fn get_bounds( + &mut self, + xMin: &mut core::ffi::c_double, + xMax: &mut core::ffi::c_double, + yMin: &mut core::ffi::c_double, + yMax: &mut core::ffi::c_double, + zMin: &mut core::ffi::c_double, + zMax: &mut core::ffi::c_double, + ) -> (); + fn get_bound(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn contains_point( + &mut self, + px: core::ffi::c_double, + py: core::ffi::c_double, + pz: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_length(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn get_max_length(&mut self) -> core::ffi::c_double; + fn get_diagonal_length(&mut self) -> core::ffi::c_double; + fn inflate(&mut self, delta: core::ffi::c_double) -> (); + fn scale( + &mut self, + sx: core::ffi::c_double, + sy: core::ffi::c_double, + sz: core::ffi::c_double, + ) -> (); + fn scale_about_center(&mut self, s: core::ffi::c_double) -> (); + fn reset(&mut self) -> (); +} +pub trait VtkBox { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_x_min( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn get_x_min( + &mut self, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, + ) -> (); + fn set_x_max( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn get_x_max( + &mut self, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, + ) -> (); + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn get_bounds( + &mut self, + xMin: &mut core::ffi::c_double, + xMax: &mut core::ffi::c_double, + yMin: &mut core::ffi::c_double, + yMax: &mut core::ffi::c_double, + zMin: &mut core::ffi::c_double, + zMax: &mut core::ffi::c_double, + ) -> (); +} +pub trait VtkCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, c: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, c: *mut core::ffi::c_void) -> (); + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn is_linear(&mut self) -> core::ffi::c_int; + fn requires_initialization(&mut self) -> core::ffi::c_int; + fn is_explicit_cell(&mut self) -> core::ffi::c_int; + fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int; + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_point_ids(&mut self) -> *mut core::ffi::c_void; + fn get_point_id(&mut self, ptId: core::ffi::c_int) -> core::ffi::c_longlong; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn intersect_with_cell( + &mut self, + other: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_length_2(&mut self) -> core::ffi::c_double; + fn is_primary_cell(&mut self) -> core::ffi::c_int; +} +pub trait VtkCell3D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_inside_out(&mut self) -> bool; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn set_merge_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_merge_tolerance_min_value(&mut self) -> core::ffi::c_double; + fn get_merge_tolerance_max_value(&mut self) -> core::ffi::c_double; + fn get_merge_tolerance(&mut self) -> core::ffi::c_double; +} +pub trait VtkCellArray { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool; + fn allocate_exact( + &mut self, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool; + fn allocate_copy(&mut self, other: *mut core::ffi::c_void) -> bool; + fn resize_exact( + &mut self, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool; + fn initialize(&mut self) -> (); + fn reset(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn is_valid(&mut self) -> bool; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_number_of_offsets(&mut self) -> core::ffi::c_longlong; + fn get_number_of_connectivity_ids(&mut self) -> core::ffi::c_longlong; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn set_data( + &mut self, + offsets: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + ) -> bool; + fn is_storage_64_bit(&mut self) -> bool; + fn is_storage_shareable(&mut self) -> bool; + fn use_32_bit_storage(&mut self) -> (); + fn use_64_bit_storage(&mut self) -> (); + fn use_default_storage(&mut self) -> (); + fn can_convert_to_32_bit_storage(&mut self) -> bool; + fn can_convert_to_64_bit_storage(&mut self) -> bool; + fn can_convert_to_default_storage(&mut self) -> bool; + fn convert_to_32_bit_storage(&mut self) -> bool; + fn convert_to_64_bit_storage(&mut self) -> bool; + fn convert_to_default_storage(&mut self) -> bool; + fn convert_to_smallest_storage(&mut self) -> bool; + fn get_offsets_array(&mut self) -> *mut core::ffi::c_void; + fn get_offsets_array_32(&mut self) -> *mut core::ffi::c_void; + fn get_offsets_array_64(&mut self) -> *mut core::ffi::c_void; + fn get_connectivity_array(&mut self) -> *mut core::ffi::c_void; + fn get_connectivity_array_32(&mut self) -> *mut core::ffi::c_void; + fn get_connectivity_array_64(&mut self) -> *mut core::ffi::c_void; + fn is_homogeneous(&mut self) -> core::ffi::c_longlong; + fn init_traversal(&mut self) -> (); + fn get_cell_size(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn insert_next_cell( + &mut self, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn insert_cell_point(&mut self, id: core::ffi::c_longlong) -> (); + fn update_cell_count(&mut self, npts: core::ffi::c_int) -> (); + fn get_traversal_cell_id(&mut self) -> core::ffi::c_longlong; + fn set_traversal_cell_id(&mut self, cellId: core::ffi::c_longlong) -> (); + fn reverse_cell_at_id(&mut self, cellId: core::ffi::c_longlong) -> (); + fn replace_cell_at_id( + &mut self, + cellId: core::ffi::c_longlong, + list: *mut core::ffi::c_void, + ) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn deep_copy(&mut self, ca: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, ca: *mut core::ffi::c_void) -> (); + fn append( + &mut self, + src: *mut core::ffi::c_void, + pointOffset: core::ffi::c_longlong, + ) -> (); + fn export_legacy_format(&mut self, data: *mut core::ffi::c_void) -> (); + fn import_legacy_format(&mut self, data: *mut core::ffi::c_void) -> (); + fn append_legacy_format( + &mut self, + data: *mut core::ffi::c_void, + ptOffset: core::ffi::c_longlong, + ) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn set_number_of_cells(&mut self, p0: core::ffi::c_longlong) -> (); + fn estimate_size( + &mut self, + numCells: core::ffi::c_longlong, + maxPtsPerCell: core::ffi::c_int, + ) -> core::ffi::c_longlong; + fn get_size(&mut self) -> core::ffi::c_longlong; + fn get_number_of_connectivity_entries(&mut self) -> core::ffi::c_longlong; + fn get_insert_location(&mut self, npts: core::ffi::c_int) -> core::ffi::c_longlong; + fn get_traversal_location(&mut self) -> core::ffi::c_longlong; + fn set_traversal_location(&mut self, loc: core::ffi::c_longlong) -> (); + fn reverse_cell(&mut self, loc: core::ffi::c_longlong) -> (); + fn set_cells( + &mut self, + ncells: core::ffi::c_longlong, + cells: *mut core::ffi::c_void, + ) -> (); + fn get_data(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCellArrayIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_cell_array(&mut self) -> *mut core::ffi::c_void; + fn go_to_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn go_to_first_cell(&mut self) -> (); + fn go_to_next_cell(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> bool; + fn get_current_cell_id(&mut self) -> core::ffi::c_longlong; + fn replace_current_cell(&mut self, list: *mut core::ffi::c_void) -> (); + fn reverse_current_cell(&mut self) -> (); +} +pub trait VtkCellData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCellIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn init_traversal(&mut self) -> (); + fn go_to_next_cell(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; + fn get_point_ids(&mut self) -> *mut core::ffi::c_void; + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn get_faces(&mut self) -> *mut core::ffi::c_void; + fn get_cell(&mut self, cell: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_faces(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkCellLinks { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn build_links(&mut self, data: *mut core::ffi::c_void) -> (); + fn allocate( + &mut self, + numLinks: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> (); + fn initialize(&mut self) -> (); + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn insert_next_point(&mut self, numLinks: core::ffi::c_int) -> core::ffi::c_longlong; + fn insert_next_cell_reference( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> (); + fn delete_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn remove_cell_reference( + &mut self, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, + ) -> (); + fn add_cell_reference( + &mut self, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, + ) -> (); + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); +} +pub trait VtkCellLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_cells_per_bucket(&mut self, N: core::ffi::c_int) -> (); + fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int; + fn get_cells(&mut self, bucket: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_buckets(&mut self) -> core::ffi::c_int; + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn build_locator_if_needed(&mut self) -> (); + fn force_build_locator(&mut self) -> (); + fn build_locator_internal(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkCellLocatorStrategy { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_cell_locator(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCellTypes { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn insert_cell( + &mut self, + id: core::ffi::c_longlong, + type_: core::ffi::c_uchar, + loc: core::ffi::c_longlong, + ) -> (); + fn insert_next_cell( + &mut self, + type_: core::ffi::c_uchar, + loc: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn set_cell_types( + &mut self, + ncells: core::ffi::c_longlong, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ) -> (); + fn get_cell_location( + &mut self, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn delete_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn get_number_of_types(&mut self) -> core::ffi::c_longlong; + fn is_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int; + fn insert_next_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_longlong; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_class_name_from_type_id(&mut self, typeId: core::ffi::c_int) -> &str; + fn get_type_id_from_class_name(&mut self, classname: &str) -> core::ffi::c_int; + fn is_linear(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int; + fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void; + fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkClosestNPointsStrategy { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_closest_n_points(&mut self, _arg: core::ffi::c_int) -> (); + fn get_closest_n_points_min_value(&mut self) -> core::ffi::c_int; + fn get_closest_n_points_max_value(&mut self) -> core::ffi::c_int; + fn get_closest_n_points(&mut self) -> core::ffi::c_int; +} +pub trait VtkClosestPointStrategy { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_point_locator(&mut self) -> *mut core::ffi::c_void; + fn select_cell( + &mut self, + self_: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkColor3 {} +pub trait VtkColor3d { + fn set( + &mut self, + red: &core::ffi::c_double, + green: &core::ffi::c_double, + blue: &core::ffi::c_double, + ) -> (); + fn set_red(&mut self, red: &core::ffi::c_double) -> (); + fn get_red(&mut self) -> core::ffi::c_double; + fn set_green(&mut self, green: &core::ffi::c_double) -> (); + fn get_green(&mut self) -> core::ffi::c_double; + fn set_blue(&mut self, blue: &core::ffi::c_double) -> (); + fn get_blue(&mut self) -> core::ffi::c_double; +} +pub trait VtkColor3f { + fn set( + &mut self, + red: &core::ffi::c_float, + green: &core::ffi::c_float, + blue: &core::ffi::c_float, + ) -> (); + fn set_red(&mut self, red: &core::ffi::c_float) -> (); + fn get_red(&mut self) -> core::ffi::c_float; + fn set_green(&mut self, green: &core::ffi::c_float) -> (); + fn get_green(&mut self) -> core::ffi::c_float; + fn set_blue(&mut self, blue: &core::ffi::c_float) -> (); + fn get_blue(&mut self) -> core::ffi::c_float; +} +pub trait VtkColor3ub { + fn set( + &mut self, + red: &core::ffi::c_uchar, + green: &core::ffi::c_uchar, + blue: &core::ffi::c_uchar, + ) -> (); + fn set_red(&mut self, red: &core::ffi::c_uchar) -> (); + fn get_red(&mut self) -> core::ffi::c_uchar; + fn set_green(&mut self, green: &core::ffi::c_uchar) -> (); + fn get_green(&mut self) -> core::ffi::c_uchar; + fn set_blue(&mut self, blue: &core::ffi::c_uchar) -> (); + fn get_blue(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkColor4 {} +pub trait VtkColor4d { + fn set( + &mut self, + red: &core::ffi::c_double, + green: &core::ffi::c_double, + blue: &core::ffi::c_double, + ) -> (); + fn set_red(&mut self, red: &core::ffi::c_double) -> (); + fn get_red(&mut self) -> core::ffi::c_double; + fn set_green(&mut self, green: &core::ffi::c_double) -> (); + fn get_green(&mut self) -> core::ffi::c_double; + fn set_blue(&mut self, blue: &core::ffi::c_double) -> (); + fn get_blue(&mut self) -> core::ffi::c_double; + fn set_alpha(&mut self, alpha: &core::ffi::c_double) -> (); + fn get_alpha(&mut self) -> core::ffi::c_double; +} +pub trait VtkColor4f { + fn set( + &mut self, + red: &core::ffi::c_float, + green: &core::ffi::c_float, + blue: &core::ffi::c_float, + ) -> (); + fn set_red(&mut self, red: &core::ffi::c_float) -> (); + fn get_red(&mut self) -> core::ffi::c_float; + fn set_green(&mut self, green: &core::ffi::c_float) -> (); + fn get_green(&mut self) -> core::ffi::c_float; + fn set_blue(&mut self, blue: &core::ffi::c_float) -> (); + fn get_blue(&mut self) -> core::ffi::c_float; + fn set_alpha(&mut self, alpha: &core::ffi::c_float) -> (); + fn get_alpha(&mut self) -> core::ffi::c_float; +} +pub trait VtkColor4ub { + fn set( + &mut self, + red: &core::ffi::c_uchar, + green: &core::ffi::c_uchar, + blue: &core::ffi::c_uchar, + ) -> (); + fn set_red(&mut self, red: &core::ffi::c_uchar) -> (); + fn get_red(&mut self) -> core::ffi::c_uchar; + fn set_green(&mut self, green: &core::ffi::c_uchar) -> (); + fn get_green(&mut self) -> core::ffi::c_uchar; + fn set_blue(&mut self, blue: &core::ffi::c_uchar) -> (); + fn get_blue(&mut self) -> core::ffi::c_uchar; + fn set_alpha(&mut self, alpha: &core::ffi::c_uchar) -> (); + fn get_alpha(&mut self) -> core::ffi::c_uchar; +} +pub trait VtkCompositeDataIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_data_set(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn init_traversal(&mut self) -> (); + fn init_reverse_traversal(&mut self) -> (); + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void; + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void; + fn has_current_meta_data(&mut self) -> core::ffi::c_int; + fn set_skip_empty_nodes(&mut self, _arg: core::ffi::c_int) -> (); + fn get_skip_empty_nodes(&mut self) -> core::ffi::c_int; + fn skip_empty_nodes_on(&mut self) -> (); + fn skip_empty_nodes_off(&mut self) -> (); + fn get_current_flat_index(&mut self) -> core::ffi::c_uint; + fn get_reverse(&mut self) -> core::ffi::c_int; +} +pub trait VtkCompositeDataSet { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, input: *mut core::ffi::c_void) -> (); + fn set_data_set( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> (); + fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn name(&mut self) -> *mut core::ffi::c_void; + fn current_process_can_load_block(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCone { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_angle_min_value(&mut self) -> core::ffi::c_double; + fn get_angle_max_value(&mut self) -> core::ffi::c_double; + fn get_angle(&mut self) -> core::ffi::c_double; +} +pub trait VtkConvexPointSet { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn has_fixed_topology(&mut self) -> core::ffi::c_int; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn requires_initialization(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn is_primary_cell(&mut self) -> core::ffi::c_int; +} +pub trait VtkCubicLine { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkCylinder { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_axis( + &mut self, + ax: core::ffi::c_double, + ay: core::ffi::c_double, + az: core::ffi::c_double, + ) -> (); +} +pub trait VtkDataAssembly { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn initialize_from_xml(&mut self, xmlcontents: &str) -> bool; + fn get_root_node(&mut self) -> core::ffi::c_int; + fn set_root_node_name(&mut self, name: &str) -> (); + fn get_root_node_name(&mut self) -> &str; + fn add_node(&mut self, name: &str, parent: core::ffi::c_int) -> core::ffi::c_int; + fn add_subtree( + &mut self, + parent: core::ffi::c_int, + other: *mut core::ffi::c_void, + otherParent: core::ffi::c_int, + ) -> core::ffi::c_int; + fn remove_node(&mut self, id: core::ffi::c_int) -> bool; + fn set_node_name(&mut self, id: core::ffi::c_int, name: &str) -> (); + fn get_node_name(&mut self, id: core::ffi::c_int) -> &str; + fn get_first_node_by_path(&mut self, path: &str) -> core::ffi::c_int; + fn add_data_set_index( + &mut self, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool; + fn add_data_set_index_range( + &mut self, + id: core::ffi::c_int, + index_start: core::ffi::c_uint, + count: core::ffi::c_int, + ) -> bool; + fn remove_data_set_index( + &mut self, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool; + fn remove_all_data_set_indices( + &mut self, + id: core::ffi::c_int, + traverse_subtree: bool, + ) -> bool; + fn find_first_node_with_name( + &mut self, + name: &str, + traversal_order: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_number_of_children(&mut self, parent: core::ffi::c_int) -> core::ffi::c_int; + fn get_child( + &mut self, + parent: core::ffi::c_int, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_child_index( + &mut self, + parent: core::ffi::c_int, + child: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_parent(&mut self, id: core::ffi::c_int) -> core::ffi::c_int; + fn has_attribute(&mut self, id: core::ffi::c_int, name: &str) -> bool; + fn set_attribute(&mut self, id: core::ffi::c_int, name: &str, value: &str) -> (); + fn get_attribute(&mut self, id: core::ffi::c_int, name: &str, value: &str) -> bool; + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: &str, + default_value: &str, + ) -> &str; + fn visit( + &mut self, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn is_node_name_valid(&mut self, name: &str) -> bool; + fn is_node_name_reserved(&mut self, name: &str) -> bool; +} +pub trait VtkDataAssemblyUtilities { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn hierarchy_name(&mut self) -> &str; + fn generate_hierarchy( + &mut self, + input: *mut core::ffi::c_void, + hierarchy: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> bool; +} +pub trait VtkDataAssemblyVisitor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn initialize(&mut self) -> (); + fn release_data(&mut self) -> (); + fn get_data_released(&mut self) -> core::ffi::c_int; + fn set_global_release_data_flag(&mut self, val: core::ffi::c_int) -> (); + fn global_release_data_flag_on(&mut self) -> (); + fn global_release_data_flag_off(&mut self) -> (); + fn get_global_release_data_flag(&mut self) -> core::ffi::c_int; + fn set_field_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_field_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_update_time(&mut self) -> core::ffi::c_ulong; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn copy_information_from_pipeline(&mut self, info: *mut core::ffi::c_void) -> (); + fn copy_information_to_pipeline(&mut self, info: *mut core::ffi::c_void) -> (); + fn get_active_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_named_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: &str, + ) -> *mut core::ffi::c_void; + fn remove_named_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: &str, + ) -> (); + fn set_active_attribute( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeName: &str, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_active_attribute_info( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + name: &str, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + numTuples: core::ffi::c_int, + ) -> (); + fn set_point_data_active_scalar_info( + &mut self, + info: *mut core::ffi::c_void, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ) -> (); + fn data_has_been_generated(&mut self) -> (); + fn prepare_for_new_data(&mut self) -> (); + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn get_attributes(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_ghost_array(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_attributes_as_field_data( + &mut self, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_attribute_type_for_array( + &mut self, + arr: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; + fn get_association_type_as_string( + &mut self, + associationType: core::ffi::c_int, + ) -> &str; + fn get_association_type_from_string( + &mut self, + associationName: &str, + ) -> core::ffi::c_int; + fn data_type_name(&mut self) -> *mut core::ffi::c_void; + fn data_object(&mut self) -> *mut core::ffi::c_void; + fn data_extent_type(&mut self) -> *mut core::ffi::c_void; + fn data_extent(&mut self) -> *mut core::ffi::c_void; + fn all_pieces_extent(&mut self) -> *mut core::ffi::c_void; + fn data_piece_number(&mut self) -> *mut core::ffi::c_void; + fn data_number_of_pieces(&mut self) -> *mut core::ffi::c_void; + fn data_number_of_ghost_levels(&mut self) -> *mut core::ffi::c_void; + fn data_time_step(&mut self) -> *mut core::ffi::c_void; + fn point_data_vector(&mut self) -> *mut core::ffi::c_void; + fn cell_data_vector(&mut self) -> *mut core::ffi::c_void; + fn vertex_data_vector(&mut self) -> *mut core::ffi::c_void; + fn edge_data_vector(&mut self) -> *mut core::ffi::c_void; + fn field_array_type(&mut self) -> *mut core::ffi::c_void; + fn field_association(&mut self) -> *mut core::ffi::c_void; + fn field_attribute_type(&mut self) -> *mut core::ffi::c_void; + fn field_active_attribute(&mut self) -> *mut core::ffi::c_void; + fn field_number_of_components(&mut self) -> *mut core::ffi::c_void; + fn field_number_of_tuples(&mut self) -> *mut core::ffi::c_void; + fn field_operation(&mut self) -> *mut core::ffi::c_void; + fn field_range(&mut self) -> *mut core::ffi::c_void; + fn piece_extent(&mut self) -> *mut core::ffi::c_void; + fn field_name(&mut self) -> *mut core::ffi::c_void; + fn origin(&mut self) -> *mut core::ffi::c_void; + fn spacing(&mut self) -> *mut core::ffi::c_void; + fn direction(&mut self) -> *mut core::ffi::c_void; + fn bounding_box(&mut self) -> *mut core::ffi::c_void; + fn sil(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkDataObjectCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkDataObjectTree { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new_tree_iterator(&mut self) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn set_data_set( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> (); + fn set_data_set_from( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> (); + fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_meta_data(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn has_meta_data(&mut self, iter: *mut core::ffi::c_void) -> core::ffi::c_int; + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkDataObjectTreeIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void; + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void; + fn has_current_meta_data(&mut self) -> core::ffi::c_int; + fn get_current_flat_index(&mut self) -> core::ffi::c_uint; + fn set_visit_only_leaves(&mut self, _arg: core::ffi::c_int) -> (); + fn get_visit_only_leaves(&mut self) -> core::ffi::c_int; + fn visit_only_leaves_on(&mut self) -> (); + fn visit_only_leaves_off(&mut self) -> (); + fn set_traverse_sub_tree(&mut self, _arg: core::ffi::c_int) -> (); + fn get_traverse_sub_tree(&mut self) -> core::ffi::c_int; + fn traverse_sub_tree_on(&mut self) -> (); + fn traverse_sub_tree_off(&mut self) -> (); +} +pub trait VtkDataObjectTypes { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_class_name_from_type_id(&mut self, typeId: core::ffi::c_int) -> &str; + fn get_type_id_from_class_name(&mut self, classname: &str) -> core::ffi::c_int; + fn new_data_object(&mut self, classname: &str) -> *mut core::ffi::c_void; + fn type_id_is_a( + &mut self, + typeId: core::ffi::c_int, + targetTypeId: core::ffi::c_int, + ) -> bool; + fn get_common_base_type_id( + &mut self, + typeA: core::ffi::c_int, + typeB: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkDataSet { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn copy_attributes(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn new_cell_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn set_cell_order_and_rational_weights( + &mut self, + cellId: core::ffi::c_longlong, + cell: *mut core::ffi::c_void, + ) -> (); + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn find_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_cell_data(&mut self) -> *mut core::ffi::c_void; + fn get_point_data(&mut self) -> *mut core::ffi::c_void; + fn squeeze(&mut self) -> (); + fn compute_bounds(&mut self) -> (); + fn get_length(&mut self) -> core::ffi::c_double; + fn initialize(&mut self) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn check_attributes(&mut self) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn has_any_ghost_cells(&mut self) -> bool; + fn has_any_ghost_points(&mut self) -> bool; + fn has_any_blank_cells(&mut self) -> bool; + fn has_any_blank_points(&mut self) -> bool; + fn get_point_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn update_point_ghost_array_cache(&mut self) -> (); + fn allocate_point_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn get_cell_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn update_cell_ghost_array_cache(&mut self) -> (); + fn allocate_cell_ghost_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkDataSetAttributes { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn update(&mut self) -> (); + fn deep_copy(&mut self, pd: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, pd: *mut core::ffi::c_void) -> (); + fn ghost_array_name(&mut self) -> &str; + fn set_scalars(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_scalars(&mut self, name: &str) -> core::ffi::c_int; + fn get_scalars(&mut self) -> *mut core::ffi::c_void; + fn set_vectors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_vectors(&mut self, name: &str) -> core::ffi::c_int; + fn get_vectors(&mut self) -> *mut core::ffi::c_void; + fn set_normals(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_normals(&mut self, name: &str) -> core::ffi::c_int; + fn get_normals(&mut self) -> *mut core::ffi::c_void; + fn set_tangents(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_tangents(&mut self, name: &str) -> core::ffi::c_int; + fn get_tangents(&mut self) -> *mut core::ffi::c_void; + fn set_t_coords(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_t_coords(&mut self, name: &str) -> core::ffi::c_int; + fn get_t_coords(&mut self) -> *mut core::ffi::c_void; + fn set_tensors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_tensors(&mut self, name: &str) -> core::ffi::c_int; + fn get_tensors(&mut self) -> *mut core::ffi::c_void; + fn set_global_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_global_ids(&mut self, name: &str) -> core::ffi::c_int; + fn get_global_ids(&mut self) -> *mut core::ffi::c_void; + fn set_pedigree_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_pedigree_ids(&mut self, name: &str) -> core::ffi::c_int; + fn get_pedigree_ids(&mut self) -> *mut core::ffi::c_void; + fn set_rational_weights(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int; + fn set_active_rational_weights(&mut self, name: &str) -> core::ffi::c_int; + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void; + fn set_higher_order_degrees( + &mut self, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_active_higher_order_degrees(&mut self, name: &str) -> core::ffi::c_int; + fn get_higher_order_degrees(&mut self) -> *mut core::ffi::c_void; + fn set_active_attribute( + &mut self, + name: &str, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn is_array_an_attribute(&mut self, idx: core::ffi::c_int) -> core::ffi::c_int; + fn set_attribute( + &mut self, + aa: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_attribute( + &mut self, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_abstract_attribute( + &mut self, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_attribute_type_as_string(&mut self, attributeType: core::ffi::c_int) -> &str; + fn get_long_attribute_type_as_string( + &mut self, + attributeType: core::ffi::c_int, + ) -> &str; + fn set_copy_attribute( + &mut self, + index: core::ffi::c_int, + value: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_attribute( + &mut self, + index: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_copy_scalars(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_scalars(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_scalars_on(&mut self) -> (); + fn copy_scalars_off(&mut self) -> (); + fn set_copy_vectors(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_vectors(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_vectors_on(&mut self) -> (); + fn copy_vectors_off(&mut self) -> (); + fn set_copy_normals(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_normals(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_normals_on(&mut self) -> (); + fn copy_normals_off(&mut self) -> (); + fn set_copy_tangents(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_tangents(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_tangents_on(&mut self) -> (); + fn copy_tangents_off(&mut self) -> (); + fn set_copy_t_coords(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_t_coords(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_t_coords_on(&mut self) -> (); + fn copy_t_coords_off(&mut self) -> (); + fn set_copy_tensors(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> (); + fn get_copy_tensors(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_tensors_on(&mut self) -> (); + fn copy_tensors_off(&mut self) -> (); + fn set_copy_global_ids( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_global_ids(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_global_ids_on(&mut self) -> (); + fn copy_global_ids_off(&mut self) -> (); + fn set_copy_pedigree_ids( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_pedigree_ids(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_pedigree_ids_on(&mut self) -> (); + fn copy_pedigree_ids_off(&mut self) -> (); + fn set_copy_rational_weights( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_rational_weights(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int; + fn copy_rational_weights_on(&mut self) -> (); + fn copy_rational_weights_off(&mut self) -> (); + fn set_copy_higher_order_degrees( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> (); + fn get_copy_higher_order_degrees( + &mut self, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + fn copy_higher_order_degrees_on(&mut self) -> (); + fn copy_higher_order_degrees_off(&mut self) -> (); + fn copy_all_on(&mut self, ctype: core::ffi::c_int) -> (); + fn copy_all_off(&mut self, ctype: core::ffi::c_int) -> (); + fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> (); + fn copy_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> (); + fn setup_for_copy(&mut self, pd: *mut core::ffi::c_void) -> (); + fn copy_data( + &mut self, + fromPd: *mut core::ffi::c_void, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, + ) -> (); + fn copy_tuple( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, + ) -> (); + fn copy_tuples( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ) -> (); + fn interpolate_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> (); + fn interpolate_edge( + &mut self, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + t: core::ffi::c_double, + ) -> (); + fn interpolate_time( + &mut self, + from1: *mut core::ffi::c_void, + from2: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + t: core::ffi::c_double, + ) -> (); +} +pub trait VtkDataSetAttributesFieldList { + fn reset(&mut self) -> (); + fn initialize_field_list(&mut self, dsa: *mut core::ffi::c_void) -> (); + fn intersect_field_list(&mut self, dsa: *mut core::ffi::c_void) -> (); + fn union_field_list(&mut self, dsa: *mut core::ffi::c_void) -> (); + fn copy_allocate( + &mut self, + output: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> (); + fn copy_data( + &mut self, + inputIndex: core::ffi::c_int, + input: *mut core::ffi::c_void, + fromId: core::ffi::c_longlong, + output: *mut core::ffi::c_void, + toId: core::ffi::c_longlong, + ) -> (); +} +pub trait VtkDataSetCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkDataSetCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_next_data_set(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_data_set(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkDirectedAcyclicGraph { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkDirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool; +} +pub trait VtkDistributedGraphHelper { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_owner(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_vertex_index(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_edge_owner(&mut self, e_id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_edge_index(&mut self, e_id: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn make_distributed_id( + &mut self, + owner: core::ffi::c_int, + local: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn synchronize(&mut self) -> (); + fn clone(&mut self) -> *mut core::ffi::c_void; + fn distributedvertexids(&mut self) -> *mut core::ffi::c_void; + fn distributededgeids(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkEdgeListIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> (); + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; + fn has_next(&mut self) -> bool; +} +pub trait VtkEdgeTable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn init_edge_insertion( + &mut self, + numPoints: core::ffi::c_longlong, + storeAttributes: core::ffi::c_int, + ) -> core::ffi::c_int; + fn insert_edge( + &mut self, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn is_edge( + &mut self, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + estSize: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_longlong; + fn init_traversal(&mut self) -> (); + fn get_next_edge( + &mut self, + p1: &mut core::ffi::c_longlong, + p2: &mut core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn reset(&mut self) -> (); +} +pub trait VtkEmptyCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkExplicitStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_data_dimension(&mut self) -> core::ffi::c_int; + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn set_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn set_cells(&mut self, cells: *mut core::ffi::c_void) -> (); + fn get_cells(&mut self) -> *mut core::ffi::c_void; + fn build_links(&mut self) -> (); + fn get_links(&mut self) -> *mut core::ffi::c_void; + fn compute_cell_structured_coords( + &mut self, + cellId: core::ffi::c_longlong, + i: &mut core::ffi::c_int, + j: &mut core::ffi::c_int, + k: &mut core::ffi::c_int, + adjustForExtent: bool, + ) -> (); + fn compute_cell_id( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ) -> core::ffi::c_longlong; + fn compute_faces_connectivity_flags_array(&mut self) -> (); + fn set_faces_connectivity_flags_array_name(&mut self, _arg: &str) -> (); + fn blank_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn un_blank_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn has_any_blank_cells(&mut self) -> bool; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_ghost(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn has_any_ghost_cells(&mut self) -> bool; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn check_and_reorder_faces(&mut self) -> (); +} +pub trait VtkExtractStructuredGridHelper { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_valid(&mut self) -> bool; + fn get_size(&mut self, dim: core::ffi::c_int) -> core::ffi::c_int; + fn get_mapped_index( + &mut self, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_mapped_index_from_extent_value( + &mut self, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_mapped_extent_value( + &mut self, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_mapped_extent_value_from_index( + &mut self, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkFieldData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> (); + fn allocate_arrays(&mut self, num: core::ffi::c_int) -> (); + fn get_number_of_arrays(&mut self) -> core::ffi::c_int; + fn add_array(&mut self, array: *mut core::ffi::c_void) -> core::ffi::c_int; + fn null_data(&mut self, id: core::ffi::c_longlong) -> (); + fn remove_array(&mut self, name: &str) -> (); + fn get_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_abstract_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn has_array(&mut self, name: &str) -> core::ffi::c_int; + fn get_array_name(&mut self, i: core::ffi::c_int) -> &str; + fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> (); + fn copy_field_on(&mut self, name: &str) -> (); + fn copy_field_off(&mut self, name: &str) -> (); + fn copy_all_on(&mut self, unused: core::ffi::c_int) -> (); + fn copy_all_off(&mut self, unused: core::ffi::c_int) -> (); + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, da: *mut core::ffi::c_void) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_field( + &mut self, + ptId: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ) -> (); + fn get_array_containing_component( + &mut self, + i: core::ffi::c_int, + arrayComp: &mut core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; +} +pub trait VtkFindCellStrategy { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int; +} +pub trait VtkGenericAdaptorCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_id(&mut self) -> core::ffi::c_longlong; + fn is_in_data_set(&mut self) -> core::ffi::c_int; + fn get_type(&mut self) -> core::ffi::c_int; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn get_geometry_order(&mut self) -> core::ffi::c_int; + fn is_geometry_linear(&mut self) -> core::ffi::c_int; + fn get_attribute_order(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_highest_order_attribute( + &mut self, + ac: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn is_attribute_linear(&mut self, a: *mut core::ffi::c_void) -> core::ffi::c_int; + fn is_primary(&mut self) -> core::ffi::c_int; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn get_number_of_boundaries(&mut self, dim: core::ffi::c_int) -> core::ffi::c_int; + fn get_number_of_dof_nodes(&mut self) -> core::ffi::c_int; + fn get_point_iterator(&mut self, it: *mut core::ffi::c_void) -> (); + fn new_cell_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_iterator( + &mut self, + boundaries: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ) -> (); + fn count_neighbors(&mut self, boundary: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_neighbors( + &mut self, + boundary: *mut core::ffi::c_void, + neighbors: *mut core::ffi::c_void, + ) -> (); + fn contour( + &mut self, + values: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + attributes: *mut core::ffi::c_void, + tess: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + outCd: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + secondaryPd: *mut core::ffi::c_void, + secondaryCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + f: *mut core::ffi::c_void, + attributes: *mut core::ffi::c_void, + tess: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + outCd: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + secondaryPd: *mut core::ffi::c_void, + secondaryCd: *mut core::ffi::c_void, + ) -> (); + fn get_length_2(&mut self) -> core::ffi::c_double; + fn tessellate( + &mut self, + attributes: *mut core::ffi::c_void, + tess: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + cd: *mut core::ffi::c_void, + types: *mut core::ffi::c_void, + ) -> (); + fn is_face_on_boundary(&mut self, faceId: core::ffi::c_longlong) -> core::ffi::c_int; + fn is_on_boundary(&mut self) -> core::ffi::c_int; + fn triangulate_face( + &mut self, + attributes: *mut core::ffi::c_void, + tess: *mut core::ffi::c_void, + index: core::ffi::c_int, + points: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + cd: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_vertices_on_face( + &mut self, + faceId: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkGenericAttribute { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_name(&mut self) -> &str; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_centering(&mut self) -> core::ffi::c_int; + fn get_type(&mut self) -> core::ffi::c_int; + fn get_component_type(&mut self) -> core::ffi::c_int; + fn get_size(&mut self) -> core::ffi::c_longlong; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_max_norm(&mut self) -> core::ffi::c_double; + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); +} +pub trait VtkGenericAttributeCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_attributes(&mut self) -> core::ffi::c_int; + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn get_number_of_point_centered_components(&mut self) -> core::ffi::c_int; + fn get_max_number_of_components(&mut self) -> core::ffi::c_int; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn is_empty(&mut self) -> core::ffi::c_int; + fn get_attribute(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn find_attribute(&mut self, name: &str) -> core::ffi::c_int; + fn get_attribute_index(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; + fn insert_next_attribute(&mut self, a: *mut core::ffi::c_void) -> (); + fn insert_attribute(&mut self, i: core::ffi::c_int, a: *mut core::ffi::c_void) -> (); + fn remove_attribute(&mut self, i: core::ffi::c_int) -> (); + fn reset(&mut self) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_active_attribute(&mut self) -> core::ffi::c_int; + fn get_active_component(&mut self) -> core::ffi::c_int; + fn set_active_attribute( + &mut self, + attribute: core::ffi::c_int, + component: core::ffi::c_int, + ) -> (); + fn get_number_of_attributes_to_interpolate(&mut self) -> core::ffi::c_int; + fn set_attributes_to_interpolate_to_all(&mut self) -> (); +} +pub trait VtkGenericCell { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_points(&mut self, points: *mut core::ffi::c_void) -> (); + fn set_point_ids(&mut self, pointIds: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, c: *mut core::ffi::c_void) -> (); + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> (); + fn set_cell_type_to_empty_cell(&mut self) -> (); + fn set_cell_type_to_vertex(&mut self) -> (); + fn set_cell_type_to_poly_vertex(&mut self) -> (); + fn set_cell_type_to_line(&mut self) -> (); + fn set_cell_type_to_poly_line(&mut self) -> (); + fn set_cell_type_to_triangle(&mut self) -> (); + fn set_cell_type_to_triangle_strip(&mut self) -> (); + fn set_cell_type_to_polygon(&mut self) -> (); + fn set_cell_type_to_pixel(&mut self) -> (); + fn set_cell_type_to_quad(&mut self) -> (); + fn set_cell_type_to_tetra(&mut self) -> (); + fn set_cell_type_to_voxel(&mut self) -> (); + fn set_cell_type_to_hexahedron(&mut self) -> (); + fn set_cell_type_to_wedge(&mut self) -> (); + fn set_cell_type_to_pyramid(&mut self) -> (); + fn set_cell_type_to_pentagonal_prism(&mut self) -> (); + fn set_cell_type_to_hexagonal_prism(&mut self) -> (); + fn set_cell_type_to_polyhedron(&mut self) -> (); + fn set_cell_type_to_convex_point_set(&mut self) -> (); + fn set_cell_type_to_quadratic_edge(&mut self) -> (); + fn set_cell_type_to_cubic_line(&mut self) -> (); + fn set_cell_type_to_quadratic_triangle(&mut self) -> (); + fn set_cell_type_to_bi_quadratic_triangle(&mut self) -> (); + fn set_cell_type_to_quadratic_quad(&mut self) -> (); + fn set_cell_type_to_quadratic_polygon(&mut self) -> (); + fn set_cell_type_to_quadratic_tetra(&mut self) -> (); + fn set_cell_type_to_quadratic_hexahedron(&mut self) -> (); + fn set_cell_type_to_quadratic_wedge(&mut self) -> (); + fn set_cell_type_to_quadratic_pyramid(&mut self) -> (); + fn set_cell_type_to_quadratic_linear_quad(&mut self) -> (); + fn set_cell_type_to_bi_quadratic_quad(&mut self) -> (); + fn set_cell_type_to_quadratic_linear_wedge(&mut self) -> (); + fn set_cell_type_to_bi_quadratic_quadratic_wedge(&mut self) -> (); + fn set_cell_type_to_tri_quadratic_hexahedron(&mut self) -> (); + fn set_cell_type_to_tri_quadratic_pyramid(&mut self) -> (); + fn set_cell_type_to_bi_quadratic_quadratic_hexahedron(&mut self) -> (); + fn set_cell_type_to_lagrange_triangle(&mut self) -> (); + fn set_cell_type_to_lagrange_tetra(&mut self) -> (); + fn set_cell_type_to_lagrange_curve(&mut self) -> (); + fn set_cell_type_to_lagrange_quadrilateral(&mut self) -> (); + fn set_cell_type_to_lagrange_hexahedron(&mut self) -> (); + fn set_cell_type_to_lagrange_wedge(&mut self) -> (); + fn set_cell_type_to_bezier_triangle(&mut self) -> (); + fn set_cell_type_to_bezier_tetra(&mut self) -> (); + fn set_cell_type_to_bezier_curve(&mut self) -> (); + fn set_cell_type_to_bezier_quadrilateral(&mut self) -> (); + fn set_cell_type_to_bezier_hexahedron(&mut self) -> (); + fn set_cell_type_to_bezier_wedge(&mut self) -> (); + fn instantiate_cell(&mut self, cellType: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_representative_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkGenericCellIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn begin(&mut self) -> (); + fn is_at_end(&mut self) -> core::ffi::c_int; + fn new_cell(&mut self) -> *mut core::ffi::c_void; + fn get_cell(&mut self, c: *mut core::ffi::c_void) -> (); + fn next(&mut self) -> (); +} +pub trait VtkGenericCellTessellator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn tessellate_face( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn tessellate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn set_error_metrics(&mut self, someErrorMetrics: *mut core::ffi::c_void) -> (); + fn get_error_metrics(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, ds: *mut core::ffi::c_void) -> (); + fn init_error_metrics(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_measurement(&mut self) -> core::ffi::c_int; + fn set_measurement(&mut self, _arg: core::ffi::c_int) -> (); +} +pub trait VtkGenericDataSet { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_cells(&mut self, dim: core::ffi::c_int) -> core::ffi::c_longlong; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); + fn new_cell_iterator(&mut self, dim: core::ffi::c_int) -> *mut core::ffi::c_void; + fn new_boundary_iterator( + &mut self, + dim: core::ffi::c_int, + exteriorOnly: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn new_point_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn compute_bounds(&mut self) -> (); + fn get_length(&mut self) -> core::ffi::c_double; + fn get_attributes(&mut self) -> *mut core::ffi::c_void; + fn set_tessellator(&mut self, tessellator: *mut core::ffi::c_void) -> (); + fn get_tessellator(&mut self) -> *mut core::ffi::c_void; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_estimated_size(&mut self) -> core::ffi::c_longlong; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkGenericEdgeTable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn insert_edge( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ref_: core::ffi::c_int, + ptId: &mut core::ffi::c_longlong, + ) -> (); + fn remove_edge( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn check_edge( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ptId: &mut core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn increment_edge_reference_count( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn check_edge_reference_count( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn initialize(&mut self, start: core::ffi::c_longlong) -> (); + fn get_number_of_components(&mut self) -> core::ffi::c_int; + fn set_number_of_components(&mut self, count: core::ffi::c_int) -> (); + fn check_point(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_int; + fn remove_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn increment_point_reference_count(&mut self, ptId: core::ffi::c_longlong) -> (); + fn dump_table(&mut self) -> (); + fn load_factor(&mut self) -> (); +} +pub trait VtkGenericInterpolatedVelocityField { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_data_set(&mut self, dataset: *mut core::ffi::c_void) -> (); + fn clear_last_cell(&mut self) -> (); + fn get_last_cell(&mut self) -> *mut core::ffi::c_void; + fn get_caching(&mut self) -> core::ffi::c_int; + fn set_caching(&mut self, _arg: core::ffi::c_int) -> (); + fn caching_on(&mut self) -> (); + fn caching_off(&mut self) -> (); + fn get_cache_hit(&mut self) -> core::ffi::c_int; + fn get_cache_miss(&mut self) -> core::ffi::c_int; + fn select_vectors(&mut self, fieldName: &str) -> (); + fn get_last_data_set(&mut self) -> *mut core::ffi::c_void; + fn copy_parameters(&mut self, from: *mut core::ffi::c_void) -> (); +} +pub trait VtkGenericPointIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn begin(&mut self) -> (); + fn is_at_end(&mut self) -> core::ffi::c_int; + fn next(&mut self) -> (); + fn get_id(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkGenericSubdivisionErrorMetric { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_generic_cell(&mut self, cell: *mut core::ffi::c_void) -> (); + fn get_generic_cell(&mut self) -> *mut core::ffi::c_void; + fn set_data_set(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkGeometricErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_absolute_geometric_tolerance(&mut self) -> core::ffi::c_double; + fn set_absolute_geometric_tolerance(&mut self, value: core::ffi::c_double) -> (); + fn set_relative_geometric_tolerance( + &mut self, + value: core::ffi::c_double, + ds: *mut core::ffi::c_void, + ) -> (); + fn get_relative(&mut self) -> core::ffi::c_int; +} +pub trait VtkGraph { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_data(&mut self) -> *mut core::ffi::c_void; + fn get_edge_data(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn set_points(&mut self, points: *mut core::ffi::c_void) -> (); + fn compute_bounds(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn get_out_edges( + &mut self, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> (); + fn get_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_out_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_in_edges( + &mut self, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> (); + fn get_in_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_adjacent_vertices( + &mut self, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> (); + fn get_edges(&mut self, it: *mut core::ffi::c_void) -> (); + fn get_number_of_edges(&mut self) -> core::ffi::c_longlong; + fn get_vertices(&mut self, it: *mut core::ffi::c_void) -> (); + fn get_number_of_vertices(&mut self) -> core::ffi::c_longlong; + fn set_distributed_graph_helper(&mut self, helper: *mut core::ffi::c_void) -> (); + fn get_distributed_graph_helper(&mut self) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn copy_structure(&mut self, g: *mut core::ffi::c_void) -> (); + fn checked_shallow_copy(&mut self, g: *mut core::ffi::c_void) -> bool; + fn checked_deep_copy(&mut self, g: *mut core::ffi::c_void) -> bool; + fn squeeze(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn reorder_out_vertices( + &mut self, + v: core::ffi::c_longlong, + vertices: *mut core::ffi::c_void, + ) -> (); + fn is_same_structure(&mut self, other: *mut core::ffi::c_void) -> bool; + fn get_source_vertex(&mut self, e: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_target_vertex(&mut self, e: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_number_of_edge_points( + &mut self, + e: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn clear_edge_points(&mut self, e: core::ffi::c_longlong) -> (); + fn set_edge_point( + &mut self, + e: core::ffi::c_longlong, + i: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn add_edge_point( + &mut self, + e: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn shallow_copy_edge_points(&mut self, g: *mut core::ffi::c_void) -> (); + fn deep_copy_edge_points(&mut self, g: *mut core::ffi::c_void) -> (); + fn get_graph_internals(&mut self, modifying: bool) -> *mut core::ffi::c_void; + fn get_induced_edges( + &mut self, + verts: *mut core::ffi::c_void, + edges: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; + fn dump(&mut self) -> (); + fn get_edge_id( + &mut self, + a: core::ffi::c_longlong, + b: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn to_directed_graph(&mut self, g: *mut core::ffi::c_void) -> bool; + fn to_undirected_graph(&mut self, g: *mut core::ffi::c_void) -> bool; +} +pub trait VtkGraphEdge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_source(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_source(&mut self) -> core::ffi::c_longlong; + fn set_target(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_target(&mut self) -> core::ffi::c_longlong; + fn set_id(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_id(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkGraphInternals { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHexagonalPrism { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkHierarchicalBoxDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHierarchicalBoxDataSet { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderCurve { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_parametric_coords(&mut self) -> (); + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + p1: core::ffi::c_int, + p2: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkHigherOrderHexahedron { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_parametric_coords(&mut self) -> (); + fn set_order_from_cell_data( + &mut self, + cell_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + cell_id: core::ffi::c_longlong, + ) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_longlong) -> (); + fn set_order( + &mut self, + s: core::ffi::c_int, + t: core::ffi::c_int, + u: core::ffi::c_int, + ) -> (); + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; + fn get_interp(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderInterpolation { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_varying_parameter_of_hex_edge( + &mut self, + edgeId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_fixed_parameter_of_hex_face( + &mut self, + faceId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_varying_parameter_of_wedge_edge( + &mut self, + edgeId: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_fixed_parameter_of_wedge_face( + &mut self, + faceId: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkHigherOrderQuadrilateral { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_parametric_coords(&mut self) -> (); + fn set_order_from_cell_data( + &mut self, + cell_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + cell_id: core::ffi::c_longlong, + ) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_longlong) -> (); + fn set_order(&mut self, s: core::ffi::c_int, t: core::ffi::c_int) -> (); + fn point_index_from_ijk( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderTetra { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_parametric_coords(&mut self) -> (); + fn get_order(&mut self) -> core::ffi::c_longlong; + fn compute_order(&mut self) -> core::ffi::c_longlong; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderTriangle { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_parametric_coords(&mut self) -> (); + fn get_order(&mut self) -> core::ffi::c_longlong; + fn compute_order(&mut self) -> core::ffi::c_longlong; + fn eta( + &mut self, + n: core::ffi::c_longlong, + chi: core::ffi::c_longlong, + sigma: core::ffi::c_double, + ) -> core::ffi::c_double; + fn d_eta( + &mut self, + n: core::ffi::c_longlong, + chi: core::ffi::c_longlong, + sigma: core::ffi::c_double, + ) -> core::ffi::c_double; + fn deta( + &mut self, + n: core::ffi::c_longlong, + chi: core::ffi::c_longlong, + sigma: core::ffi::c_double, + ) -> core::ffi::c_double; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHigherOrderWedge { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_parametric_coords(&mut self) -> (); + fn set_order_from_cell_data( + &mut self, + cell_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + cell_id: core::ffi::c_longlong, + ) -> (); + fn set_uniform_order_from_num_points(&mut self, numPts: core::ffi::c_longlong) -> (); + fn set_order( + &mut self, + s: core::ffi::c_int, + t: core::ffi::c_int, + u: core::ffi::c_int, + numPts: core::ffi::c_longlong, + ) -> (); + fn get_bdy_quad(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; + fn get_bdy_tri(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interp(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkHyperTree { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + branchFactor: core::ffi::c_uchar, + dimension: core::ffi::c_uchar, + numberOfChildren: core::ffi::c_uchar, + ) -> (); + fn initialize_for_reader( + &mut self, + numberOfLevels: core::ffi::c_longlong, + nbVertices: core::ffi::c_longlong, + nbVerticesOfLastLevel: core::ffi::c_longlong, + isParent: *mut core::ffi::c_void, + isMasked: *mut core::ffi::c_void, + outIsMasked: *mut core::ffi::c_void, + ) -> (); + fn build_from_breadth_first_order_descriptor( + &mut self, + descriptor: *mut core::ffi::c_void, + numberOfBits: core::ffi::c_longlong, + startIndex: core::ffi::c_longlong, + ) -> (); + fn compute_breadth_first_order_descriptor( + &mut self, + inputMask: *mut core::ffi::c_void, + numberOfVerticesPerDepth: *mut core::ffi::c_void, + descriptor: *mut core::ffi::c_void, + breadthFirstIdMap: *mut core::ffi::c_void, + ) -> (); + fn copy_structure(&mut self, ht: *mut core::ffi::c_void) -> (); + fn freeze(&mut self, mode: &str) -> *mut core::ffi::c_void; + fn set_tree_index(&mut self, treeIndex: core::ffi::c_longlong) -> (); + fn get_tree_index(&mut self) -> core::ffi::c_longlong; + fn get_number_of_levels(&mut self) -> core::ffi::c_uint; + fn get_number_of_vertices(&mut self) -> core::ffi::c_longlong; + fn get_number_of_nodes(&mut self) -> core::ffi::c_longlong; + fn get_number_of_leaves(&mut self) -> core::ffi::c_longlong; + fn get_branch_factor(&mut self) -> core::ffi::c_int; + fn get_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_children(&mut self) -> core::ffi::c_longlong; + fn get_scale(&mut self, d: core::ffi::c_uint) -> core::ffi::c_double; + fn create_instance( + &mut self, + branchFactor: core::ffi::c_uchar, + dimension: core::ffi::c_uchar, + ) -> *mut core::ffi::c_void; + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong; + fn get_actual_memory_size(&mut self) -> core::ffi::c_uint; + fn is_global_index_implicit(&mut self) -> bool; + fn set_global_index_start(&mut self, start: core::ffi::c_longlong) -> (); + fn get_global_index_start(&mut self) -> core::ffi::c_longlong; + fn set_global_index_from_local( + &mut self, + index: core::ffi::c_longlong, + global: core::ffi::c_longlong, + ) -> (); + fn get_global_index_from_local( + &mut self, + index: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_global_node_index_max(&mut self) -> core::ffi::c_longlong; + fn is_leaf(&mut self, index: core::ffi::c_longlong) -> bool; + fn subdivide_leaf( + &mut self, + index: core::ffi::c_longlong, + level: core::ffi::c_uint, + ) -> (); + fn is_terminal_node(&mut self, index: core::ffi::c_longlong) -> bool; + fn get_elder_child_index( + &mut self, + index_parent: core::ffi::c_uint, + ) -> core::ffi::c_longlong; + fn has_scales(&mut self) -> bool; +} +pub trait VtkHyperTreeCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_tree(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn is_leaf(&mut self) -> bool; + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn get_child_index(&mut self) -> core::ffi::c_int; + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); + fn to_child(&mut self, child: core::ffi::c_int) -> (); + fn to_same_vertex(&mut self, other: *mut core::ffi::c_void) -> (); + fn is_equal(&mut self, other: *mut core::ffi::c_void) -> bool; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn same_tree(&mut self, other: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_number_of_children(&mut self) -> core::ffi::c_int; + fn get_dimension(&mut self) -> core::ffi::c_int; +} +pub trait VtkHyperTreeGrid { + fn levels(&mut self) -> *mut core::ffi::c_void; + fn dimension(&mut self) -> *mut core::ffi::c_void; + fn orientation(&mut self) -> *mut core::ffi::c_void; + fn sizes(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_mode_squeeze(&mut self, _arg: &str) -> (); + fn squeeze(&mut self) -> (); + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> (); + fn copy_empty_structure(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_dimensions( + &mut self, + i: core::ffi::c_uint, + j: core::ffi::c_uint, + k: core::ffi::c_uint, + ) -> (); + fn set_extent( + &mut self, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ) -> (); + fn get_dimension(&mut self) -> core::ffi::c_uint; + fn get_1_d_axis(&mut self, axis: &mut core::ffi::c_uint) -> (); + fn get_2_d_axes( + &mut self, + axis1: &mut core::ffi::c_uint, + axis2: &mut core::ffi::c_uint, + ) -> (); + fn get_number_of_children(&mut self) -> core::ffi::c_uint; + fn set_transposed_root_indexing(&mut self, _arg: bool) -> (); + fn get_transposed_root_indexing(&mut self) -> bool; + fn set_indexing_mode_to_kji(&mut self) -> (); + fn set_indexing_mode_to_ijk(&mut self) -> (); + fn get_orientation(&mut self) -> core::ffi::c_uint; + fn get_freeze_state(&mut self) -> bool; + fn set_branch_factor(&mut self, p0: core::ffi::c_uint) -> (); + fn get_branch_factor(&mut self) -> core::ffi::c_uint; + fn get_max_number_of_trees(&mut self) -> core::ffi::c_longlong; + fn get_number_of_vertices(&mut self) -> core::ffi::c_longlong; + fn get_number_of_non_empty_trees(&mut self) -> core::ffi::c_longlong; + fn get_number_of_leaves(&mut self) -> core::ffi::c_longlong; + fn get_number_of_levels(&mut self, p0: core::ffi::c_longlong) -> core::ffi::c_uint; + fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_fixed_coordinates( + &mut self, + axis: core::ffi::c_uint, + value: core::ffi::c_double, + ) -> (); + fn set_mask(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_mask(&mut self) -> *mut core::ffi::c_void; + fn has_mask(&mut self) -> bool; + fn set_has_interface(&mut self, _arg: bool) -> (); + fn get_has_interface(&mut self) -> bool; + fn has_interface_on(&mut self) -> (); + fn has_interface_off(&mut self) -> (); + fn set_interface_normals_name(&mut self, _arg: &str) -> (); + fn set_interface_intercepts_name(&mut self, _arg: &str) -> (); + fn set_depth_limiter(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_depth_limiter(&mut self) -> core::ffi::c_uint; + fn initialize_oriented_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> (); + fn new_oriented_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_oriented_geometry_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> (); + fn new_oriented_geometry_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> (); + fn new_non_oriented_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_geometry_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> (); + fn new_non_oriented_geometry_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn find_dichotomic_x(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; + fn find_dichotomic_y(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; + fn find_dichotomic_z(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint; + fn initialize_non_oriented_von_neumann_super_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> (); + fn new_non_oriented_von_neumann_super_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_von_neumann_super_cursor_light( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> (); + fn new_non_oriented_von_neumann_super_cursor_light( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_moore_super_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> (); + fn new_non_oriented_moore_super_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize_non_oriented_moore_super_cursor_light( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> (); + fn new_non_oriented_moore_super_cursor_light( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn get_tree( + &mut self, + p0: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + fn set_tree(&mut self, p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, p0: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn recursively_initialize_pure_mask( + &mut self, + cursor: *mut core::ffi::c_void, + normale: *mut core::ffi::c_void, + ) -> bool; + fn get_pure_mask(&mut self) -> *mut core::ffi::c_void; + fn get_child_mask(&mut self, p0: core::ffi::c_uint) -> core::ffi::c_uint; + fn get_index_from_level_zero_coordinates( + &mut self, + p0: &mut core::ffi::c_longlong, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> (); + fn get_shifted_level_zero_index( + &mut self, + p0: core::ffi::c_longlong, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> core::ffi::c_longlong; + fn get_level_zero_coordinates_from_index( + &mut self, + p0: core::ffi::c_longlong, + p1: &mut core::ffi::c_uint, + p2: &mut core::ffi::c_uint, + p3: &mut core::ffi::c_uint, + ) -> (); + fn get_global_node_index_max(&mut self) -> core::ffi::c_longlong; + fn initialize_local_index_node(&mut self) -> (); + fn has_any_ghost_cells(&mut self) -> bool; + fn get_ghost_cells(&mut self) -> *mut core::ffi::c_void; + fn get_tree_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn allocate_tree_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_cell_data(&mut self) -> *mut core::ffi::c_void; + fn get_attributes_as_field_data( + &mut self, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; +} +pub trait VtkHyperTreeGridNonOrientedCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); + fn get_grid(&mut self) -> *mut core::ffi::c_void; + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); +} +pub trait VtkHyperTreeGridNonOrientedGeometryCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); +} +pub trait VtkHyperTreeGridNonOrientedMooreSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); + fn get_corner_cursors( + &mut self, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool; +} +pub trait VtkHyperTreeGridNonOrientedMooreSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); + fn get_corner_cursors( + &mut self, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool; +} +pub trait VtkHyperTreeGridNonOrientedSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); + fn get_grid(&mut self) -> *mut core::ffi::c_void; + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; + fn get_information( + &mut self, + icursor: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + leaf: &mut bool, + id: &mut core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); + fn get_number_of_cursors(&mut self) -> core::ffi::c_uint; +} +pub trait VtkHyperTreeGridNonOrientedSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); + fn get_grid(&mut self) -> *mut core::ffi::c_void; + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; + fn get_information( + &mut self, + icursor: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + leaf: &mut bool, + id: &mut core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, p0: core::ffi::c_uchar) -> (); + fn to_root(&mut self) -> (); + fn to_parent(&mut self) -> (); + fn get_number_of_cursors(&mut self) -> core::ffi::c_uint; +} +pub trait VtkHyperTreeGridNonOrientedVonNeumannSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); +} +pub trait VtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); +} +pub trait VtkHyperTreeGridOrientedCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); + fn get_grid(&mut self) -> *mut core::ffi::c_void; + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); +} +pub trait VtkHyperTreeGridOrientedGeometryCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn clone(&mut self) -> *mut core::ffi::c_void; + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> (); + fn has_tree(&mut self) -> bool; + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn get_vertex_id(&mut self) -> core::ffi::c_longlong; + fn get_global_node_index(&mut self) -> core::ffi::c_longlong; + fn get_dimension(&mut self) -> core::ffi::c_uchar; + fn get_number_of_children(&mut self) -> core::ffi::c_uchar; + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> (); + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> (); + fn set_mask(&mut self, state: bool) -> (); + fn is_masked(&mut self) -> bool; + fn is_leaf(&mut self) -> bool; + fn subdivide_leaf(&mut self) -> (); + fn is_root(&mut self) -> bool; + fn get_level(&mut self) -> core::ffi::c_uint; + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> (); +} +pub trait VtkHyperTreeGridScales { + fn get_branch_factor(&mut self) -> core::ffi::c_double; + fn get_scale_x(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; + fn get_scale_y(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; + fn get_scale_z(&mut self, level: core::ffi::c_uint) -> core::ffi::c_double; + fn get_current_fail_level(&mut self) -> core::ffi::c_uint; +} +pub trait VtkImageData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn find_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn has_any_blank_points(&mut self) -> bool; + fn has_any_blank_cells(&mut self) -> bool; + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn get_voxel_gradient( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ) -> (); + fn get_data_dimension(&mut self) -> core::ffi::c_int; + fn set_extent( + &mut self, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ) -> (); + fn get_scalar_type_min( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + fn get_scalar_type_max( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + fn get_scalar_size(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_scalar_index( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> core::ffi::c_longlong; + fn get_scalar_component_as_float( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_float; + fn set_scalar_component_from_float( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_float, + ) -> (); + fn get_scalar_component_as_double( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_double; + fn set_scalar_component_from_double( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_double, + ) -> (); + fn allocate_scalars( + &mut self, + dataType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ) -> (); + fn copy_and_cast_from( + &mut self, + inData: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn set_spacing( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ) -> (); + fn set_origin( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ) -> (); + fn get_direction_matrix(&mut self) -> *mut core::ffi::c_void; + fn set_direction_matrix(&mut self, m: *mut core::ffi::c_void) -> (); + fn get_index_to_physical_matrix(&mut self) -> *mut core::ffi::c_void; + fn get_physical_to_index_matrix(&mut self) -> *mut core::ffi::c_void; + fn set_scalar_type( + &mut self, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> (); + fn get_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool; + fn get_scalar_type_as_string(&mut self) -> &str; + fn set_number_of_scalar_components( + &mut self, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn has_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> bool; + fn copy_information_from_pipeline( + &mut self, + information: *mut core::ffi::c_void, + ) -> (); + fn copy_information_to_pipeline( + &mut self, + information: *mut core::ffi::c_void, + ) -> (); + fn prepare_for_new_data(&mut self) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkImageIterator { + fn next_span(&mut self) -> (); + fn begin_span(&mut self) -> *mut core::ffi::c_void; + fn end_span(&mut self) -> *mut core::ffi::c_void; + fn is_at_end(&mut self) -> core::ffi::c_int; +} +pub trait VtkImageTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn transform_point_set( + &mut self, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ) -> (); + fn transform_points( + &mut self, + m4: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkImplicitBoolean { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn add_function(&mut self, in_: *mut core::ffi::c_void) -> (); + fn remove_function(&mut self, in_: *mut core::ffi::c_void) -> (); + fn get_function(&mut self) -> *mut core::ffi::c_void; + fn set_operation_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_operation_type_min_value(&mut self) -> core::ffi::c_int; + fn get_operation_type_max_value(&mut self) -> core::ffi::c_int; + fn get_operation_type(&mut self) -> core::ffi::c_int; + fn set_operation_type_to_union(&mut self) -> (); + fn set_operation_type_to_intersection(&mut self) -> (); + fn set_operation_type_to_difference(&mut self) -> (); + fn set_operation_type_to_union_of_magnitudes(&mut self) -> (); + fn get_operation_type_as_string(&mut self) -> &str; +} +pub trait VtkImplicitDataSet { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn set_out_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_out_value(&mut self) -> core::ffi::c_double; + fn set_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); +} +pub trait VtkImplicitFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn function_value( + &mut self, + input: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn set_transform(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_transform(&mut self) -> *mut core::ffi::c_void; + fn evaluate_function( + &mut self, + input: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkImplicitFunctionCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkImplicitHalo { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_fade_out(&mut self, _arg: core::ffi::c_double) -> (); + fn get_fade_out(&mut self) -> core::ffi::c_double; +} +pub trait VtkImplicitSelectionLoop { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_loop(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_loop(&mut self) -> *mut core::ffi::c_void; + fn set_automatic_normal_generation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_automatic_normal_generation(&mut self) -> core::ffi::c_int; + fn automatic_normal_generation_on(&mut self) -> (); + fn automatic_normal_generation_off(&mut self) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkImplicitSum { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn add_function( + &mut self, + in_: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ) -> (); + fn remove_all_functions(&mut self) -> (); + fn set_function_weight( + &mut self, + f: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ) -> (); + fn set_normalize_by_weight(&mut self, _arg: core::ffi::c_int) -> (); + fn get_normalize_by_weight(&mut self) -> core::ffi::c_int; + fn normalize_by_weight_on(&mut self) -> (); + fn normalize_by_weight_off(&mut self) -> (); +} +pub trait VtkImplicitVolume { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_volume(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_volume(&mut self) -> *mut core::ffi::c_void; + fn set_out_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_out_value(&mut self) -> core::ffi::c_double; + fn set_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); +} +pub trait VtkImplicitWindowFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_implicit_function(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_implicit_function(&mut self) -> *mut core::ffi::c_void; + fn set_window_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_window_values( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); +} +pub trait VtkInEdgeIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> (); + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn get_vertex(&mut self) -> core::ffi::c_longlong; + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; + fn has_next(&mut self) -> bool; +} +pub trait VtkIncrementalOctreeNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn get_point_id_set(&mut self) -> *mut core::ffi::c_void; + fn delete_child_nodes(&mut self) -> (); + fn set_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> (); + fn is_leaf(&mut self) -> core::ffi::c_int; + fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn export_all_point_ids_by_insertion( + &mut self, + idList: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_levels(&mut self) -> core::ffi::c_int; + fn get_id(&mut self) -> core::ffi::c_int; + fn get_point_ids(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkIncrementalOctreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_max_points_per_leaf(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_points_per_leaf_min_value(&mut self) -> core::ffi::c_int; + fn get_max_points_per_leaf_max_value(&mut self) -> core::ffi::c_int; + fn get_max_points_per_leaf(&mut self) -> core::ffi::c_int; + fn set_build_cubic_octree(&mut self, _arg: core::ffi::c_int) -> (); + fn get_build_cubic_octree(&mut self) -> core::ffi::c_int; + fn build_cubic_octree_on(&mut self) -> (); + fn build_cubic_octree_off(&mut self) -> (); + fn get_locator_points(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn get_number_of_nodes(&mut self) -> core::ffi::c_int; + fn generate_representation( + &mut self, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + ) -> (); + fn build_locator(&mut self) -> (); + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn get_root(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_levels(&mut self) -> core::ffi::c_int; +} +pub trait VtkIncrementalPointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; +} +pub trait VtkInformationQuadratureSchemeDefinitionVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn clear(&mut self, info: *mut core::ffi::c_void) -> (); + fn resize(&mut self, info: *mut core::ffi::c_void, n: core::ffi::c_int) -> (); + fn size(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn append( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + ) -> (); + fn set( + &mut self, + info: *mut core::ffi::c_void, + value: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> (); + fn get( + &mut self, + info: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); + fn save_state( + &mut self, + info: *mut core::ffi::c_void, + element: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn restore_state( + &mut self, + info: *mut core::ffi::c_void, + element: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkIntersectionCounter { + fn set_tolerance(&mut self, tol: core::ffi::c_double) -> (); + fn get_tolerance(&mut self) -> core::ffi::c_double; + fn add_intersection(&mut self, t: core::ffi::c_double) -> (); + fn reset(&mut self) -> (); + fn count_intersections(&mut self) -> core::ffi::c_int; +} +pub trait VtkIterativeClosestPointTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_source(&mut self, source: *mut core::ffi::c_void) -> (); + fn set_target(&mut self, target: *mut core::ffi::c_void) -> (); + fn get_source(&mut self) -> *mut core::ffi::c_void; + fn get_target(&mut self) -> *mut core::ffi::c_void; + fn set_locator(&mut self, locator: *mut core::ffi::c_void) -> (); + fn get_locator(&mut self) -> *mut core::ffi::c_void; + fn set_maximum_number_of_iterations(&mut self, _arg: core::ffi::c_int) -> (); + fn get_maximum_number_of_iterations(&mut self) -> core::ffi::c_int; + fn get_number_of_iterations(&mut self) -> core::ffi::c_int; + fn set_check_mean_distance(&mut self, _arg: core::ffi::c_int) -> (); + fn get_check_mean_distance(&mut self) -> core::ffi::c_int; + fn check_mean_distance_on(&mut self) -> (); + fn check_mean_distance_off(&mut self) -> (); + fn set_mean_distance_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_mean_distance_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_mean_distance_mode_max_value(&mut self) -> core::ffi::c_int; + fn get_mean_distance_mode(&mut self) -> core::ffi::c_int; + fn set_mean_distance_mode_to_rms(&mut self) -> (); + fn set_mean_distance_mode_to_absolute_value(&mut self) -> (); + fn get_mean_distance_mode_as_string(&mut self) -> &str; + fn set_maximum_mean_distance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_maximum_mean_distance(&mut self) -> core::ffi::c_double; + fn get_mean_distance(&mut self) -> core::ffi::c_double; + fn set_maximum_number_of_landmarks(&mut self, _arg: core::ffi::c_int) -> (); + fn get_maximum_number_of_landmarks(&mut self) -> core::ffi::c_int; + fn set_start_by_matching_centroids(&mut self, _arg: core::ffi::c_int) -> (); + fn get_start_by_matching_centroids(&mut self) -> core::ffi::c_int; + fn start_by_matching_centroids_on(&mut self) -> (); + fn start_by_matching_centroids_off(&mut self) -> (); + fn get_landmark_transform(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkKdNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_dim(&mut self, _arg: core::ffi::c_int) -> (); + fn get_dim(&mut self) -> core::ffi::c_int; + fn get_division_position(&mut self) -> core::ffi::c_double; + fn set_number_of_points(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn set_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> (); + fn set_data_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> (); + fn set_id(&mut self, _arg: core::ffi::c_int) -> (); + fn get_id(&mut self) -> core::ffi::c_int; + fn get_min_id(&mut self) -> core::ffi::c_int; + fn get_max_id(&mut self) -> core::ffi::c_int; + fn set_min_id(&mut self, _arg: core::ffi::c_int) -> (); + fn set_max_id(&mut self, _arg: core::ffi::c_int) -> (); + fn add_child_nodes( + &mut self, + left: *mut core::ffi::c_void, + right: *mut core::ffi::c_void, + ) -> (); + fn delete_child_nodes(&mut self) -> (); + fn get_left(&mut self) -> *mut core::ffi::c_void; + fn set_left(&mut self, left: *mut core::ffi::c_void) -> (); + fn get_right(&mut self) -> *mut core::ffi::c_void; + fn set_right(&mut self, right: *mut core::ffi::c_void) -> (); + fn get_up(&mut self) -> *mut core::ffi::c_void; + fn set_up(&mut self, up: *mut core::ffi::c_void) -> (); + fn intersects_box( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersects_sphere_2( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn intersects_region( + &mut self, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn contains_box( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn contains_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get_distance_2_to_inner_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_double; + fn print_node(&mut self, depth: core::ffi::c_int) -> (); + fn print_verbose_node(&mut self, depth: core::ffi::c_int) -> (); +} +pub trait VtkKdTree { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn timing_on(&mut self) -> (); + fn timing_off(&mut self) -> (); + fn set_timing(&mut self, _arg: core::ffi::c_int) -> (); + fn get_timing(&mut self) -> core::ffi::c_int; + fn set_min_cells(&mut self, _arg: core::ffi::c_int) -> (); + fn get_min_cells(&mut self) -> core::ffi::c_int; + fn get_number_of_regions_or_less(&mut self) -> core::ffi::c_int; + fn set_number_of_regions_or_less(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_regions_or_more(&mut self) -> core::ffi::c_int; + fn set_number_of_regions_or_more(&mut self, _arg: core::ffi::c_int) -> (); + fn get_fudge_factor(&mut self) -> core::ffi::c_double; + fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_cuts(&mut self) -> *mut core::ffi::c_void; + fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> (); + fn omit_x_partitioning(&mut self) -> (); + fn omit_y_partitioning(&mut self) -> (); + fn omit_z_partitioning(&mut self) -> (); + fn omit_xy_partitioning(&mut self) -> (); + fn omit_yz_partitioning(&mut self) -> (); + fn omit_zx_partitioning(&mut self) -> (); + fn omit_no_partitioning(&mut self) -> (); + fn set_data_set(&mut self, set: *mut core::ffi::c_void) -> (); + fn add_data_set(&mut self, set: *mut core::ffi::c_void) -> (); + fn remove_data_set(&mut self, index: core::ffi::c_int) -> (); + fn remove_all_data_sets(&mut self) -> (); + fn get_number_of_data_sets(&mut self) -> core::ffi::c_int; + fn get_data_set(&mut self, n: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_data_sets(&mut self) -> *mut core::ffi::c_void; + fn get_data_set_index(&mut self, set: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_number_of_regions(&mut self) -> core::ffi::c_int; + fn print_tree(&mut self) -> (); + fn print_verbose_tree(&mut self) -> (); + fn print_region(&mut self, id: core::ffi::c_int) -> (); + fn set_include_region_boundary_cells(&mut self, _arg: core::ffi::c_int) -> (); + fn get_include_region_boundary_cells(&mut self) -> core::ffi::c_int; + fn include_region_boundary_cells_on(&mut self) -> (); + fn include_region_boundary_cells_off(&mut self) -> (); + fn delete_cell_lists(&mut self) -> (); + fn get_cell_list(&mut self, regionID: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_boundary_cell_list( + &mut self, + regionID: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_cell_lists( + &mut self, + regions: *mut core::ffi::c_void, + set: core::ffi::c_int, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn get_region_containing_cell( + &mut self, + set: *mut core::ffi::c_void, + cellID: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn get_region_containing_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int; + fn build_locator(&mut self) -> (); + fn build_locator_from_points(&mut self, pointset: *mut core::ffi::c_void) -> (); + fn build_map_for_duplicate_points( + &mut self, + tolerance: core::ffi::c_float, + ) -> *mut core::ffi::c_void; + fn get_points_in_region( + &mut self, + regionId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn free_search_structure(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn generate_representation_using_data_bounds_on(&mut self) -> (); + fn generate_representation_using_data_bounds_off(&mut self) -> (); + fn set_generate_representation_using_data_bounds( + &mut self, + _arg: core::ffi::c_int, + ) -> (); + fn get_generate_representation_using_data_bounds(&mut self) -> core::ffi::c_int; + fn new_geometry(&mut self) -> core::ffi::c_int; + fn invalidate_geometry(&mut self) -> (); + fn copy_tree(&mut self, kd: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkKdTreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkLagrangeCurve { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkLagrangeHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeInterpolation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeQuadrilateral { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeTetra { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_face_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeTriangle { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLagrangeWedge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void; + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void; + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void; + fn get_interpolation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLine { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_level_min_value(&mut self) -> core::ffi::c_int; + fn get_max_level_max_value(&mut self) -> core::ffi::c_int; + fn get_max_level(&mut self) -> core::ffi::c_int; + fn get_level(&mut self) -> core::ffi::c_int; + fn set_automatic(&mut self, _arg: core::ffi::c_int) -> (); + fn get_automatic(&mut self) -> core::ffi::c_int; + fn automatic_on(&mut self) -> (); + fn automatic_off(&mut self) -> (); + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tolerance_min_value(&mut self) -> core::ffi::c_double; + fn get_tolerance_max_value(&mut self) -> core::ffi::c_double; + fn get_tolerance(&mut self) -> core::ffi::c_double; + fn update(&mut self) -> (); + fn initialize(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn get_build_time(&mut self) -> core::ffi::c_ulong; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); +} +pub trait VtkMappedUnstructuredGrid { + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_ids_of_cells_of_type( + &mut self, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ) -> (); + fn is_homogeneous(&mut self) -> core::ffi::c_int; + fn allocate( + &mut self, + numCells: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ) -> (); + fn set_implementation(&mut self, impl_: *mut core::ffi::c_void) -> (); + fn get_implementation(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkMappedUnstructuredGridCellIterator { + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkMeanValueCoordinatesInterpolator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkMergePoints { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkMolecule { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_atoms(&mut self) -> core::ffi::c_longlong; + fn get_number_of_bonds(&mut self) -> core::ffi::c_longlong; + fn get_atom_atomic_number( + &mut self, + atomId: core::ffi::c_longlong, + ) -> core::ffi::c_ushort; + fn set_atom_atomic_number( + &mut self, + atomId: core::ffi::c_longlong, + atomicNum: core::ffi::c_ushort, + ) -> (); + fn set_bond_order( + &mut self, + bondId: core::ffi::c_longlong, + order: core::ffi::c_ushort, + ) -> (); + fn get_bond_order(&mut self, bondId: core::ffi::c_longlong) -> core::ffi::c_ushort; + fn get_bond_length(&mut self, bondId: core::ffi::c_longlong) -> core::ffi::c_double; + fn get_atomic_position_array(&mut self) -> *mut core::ffi::c_void; + fn get_atomic_number_array(&mut self) -> *mut core::ffi::c_void; + fn get_bond_orders_array(&mut self) -> *mut core::ffi::c_void; + fn get_electronic_data(&mut self) -> *mut core::ffi::c_void; + fn set_electronic_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> (); + fn shallow_copy_structure(&mut self, m: *mut core::ffi::c_void) -> (); + fn deep_copy_structure(&mut self, m: *mut core::ffi::c_void) -> (); + fn shallow_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> (); + fn deep_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> (); + fn has_lattice(&mut self) -> bool; + fn clear_lattice(&mut self) -> (); + fn set_lattice(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn get_lattice(&mut self) -> *mut core::ffi::c_void; + fn get_atom_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn allocate_atom_ghost_array(&mut self) -> (); + fn get_bond_ghost_array(&mut self) -> *mut core::ffi::c_void; + fn allocate_bond_ghost_array(&mut self) -> (); + fn initialize( + &mut self, + atomPositions: *mut core::ffi::c_void, + atomicNumberArray: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_atom_data(&mut self) -> *mut core::ffi::c_void; + fn get_bond_data(&mut self) -> *mut core::ffi::c_void; + fn get_bond_id( + &mut self, + a: core::ffi::c_longlong, + b: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn set_atomic_number_array_name(&mut self, _arg: &str) -> (); + fn set_bond_orders_array_name(&mut self, _arg: &str) -> (); +} +pub trait VtkMultiBlockDataSet { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_blocks(&mut self, numBlocks: core::ffi::c_uint) -> (); + fn get_number_of_blocks(&mut self) -> core::ffi::c_uint; + fn get_block(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn set_block( + &mut self, + blockno: core::ffi::c_uint, + block: *mut core::ffi::c_void, + ) -> (); + fn remove_block(&mut self, blockno: core::ffi::c_uint) -> (); + fn has_meta_data(&mut self, blockno: core::ffi::c_uint) -> core::ffi::c_int; + fn get_meta_data(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkMultiPieceDataSet { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_pieces(&mut self, numpieces: core::ffi::c_uint) -> (); + fn get_number_of_pieces(&mut self) -> core::ffi::c_uint; + fn get_piece(&mut self, pieceno: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_piece_as_data_object( + &mut self, + pieceno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn set_piece( + &mut self, + pieceno: core::ffi::c_uint, + piece: *mut core::ffi::c_void, + ) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkMutableDirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_vertices( + &mut self, + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn add_vertex(&mut self) -> core::ffi::c_longlong; + fn lazy_add_vertex(&mut self) -> (); + fn lazy_add_edge( + &mut self, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + propertyArr: *mut core::ffi::c_void, + ) -> (); + fn add_graph_edge( + &mut self, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + fn add_child( + &mut self, + parent: core::ffi::c_longlong, + propertyArr: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn remove_vertex(&mut self, v: core::ffi::c_longlong) -> (); + fn remove_edge(&mut self, e: core::ffi::c_longlong) -> (); + fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> (); + fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> (); +} +pub trait VtkMutableUndirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_vertices( + &mut self, + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn add_vertex(&mut self) -> core::ffi::c_longlong; + fn lazy_add_vertex(&mut self) -> (); + fn lazy_add_edge( + &mut self, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ) -> (); + fn add_graph_edge( + &mut self, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + fn remove_vertex(&mut self, v: core::ffi::c_longlong) -> (); + fn remove_edge(&mut self, e: core::ffi::c_longlong) -> (); + fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> (); + fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> (); +} +pub trait VtkNonLinearCell { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_linear(&mut self) -> core::ffi::c_int; +} +pub trait VtkNonMergingPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_inserted_point( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_longlong; +} +pub trait VtkNonOverlappingAMR { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkOctreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_maximum_points_per_region(&mut self, _arg: core::ffi::c_int) -> (); + fn get_maximum_points_per_region(&mut self) -> core::ffi::c_int; + fn set_create_cubic_octants(&mut self, _arg: core::ffi::c_int) -> (); + fn get_create_cubic_octants(&mut self) -> core::ffi::c_int; + fn get_fudge_factor(&mut self) -> core::ffi::c_double; + fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_number_of_leaf_nodes(&mut self) -> core::ffi::c_int; + fn get_region_containing_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int; + fn build_locator(&mut self) -> (); + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn get_points_in_region( + &mut self, + leafNodeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn free_search_structure(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkOctreePointLocatorNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points(&mut self, numberOfPoints: core::ffi::c_int) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn set_data_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn get_id(&mut self) -> core::ffi::c_int; + fn get_min_id(&mut self) -> core::ffi::c_int; + fn create_child_nodes(&mut self) -> (); + fn delete_child_nodes(&mut self) -> (); + fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn intersects_region( + &mut self, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn contains_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + fn get_distance_2_to_inner_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + ) -> core::ffi::c_double; +} +pub trait VtkOrderedTriangulator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn init_triangulation( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + numPts: core::ffi::c_int, + ) -> (); + fn triangulate(&mut self) -> (); + fn template_triangulate( + &mut self, + cellType: core::ffi::c_int, + numPts: core::ffi::c_int, + numEdges: core::ffi::c_int, + ) -> (); + fn update_point_type( + &mut self, + internalId: core::ffi::c_longlong, + type_: core::ffi::c_int, + ) -> (); + fn get_point_id( + &mut self, + internalId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn set_use_templates(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_templates(&mut self) -> core::ffi::c_int; + fn use_templates_on(&mut self) -> (); + fn use_templates_off(&mut self) -> (); + fn set_pre_sorted(&mut self, _arg: core::ffi::c_int) -> (); + fn get_pre_sorted(&mut self) -> core::ffi::c_int; + fn pre_sorted_on(&mut self) -> (); + fn pre_sorted_off(&mut self) -> (); + fn set_use_two_sort_ids(&mut self, _arg: core::ffi::c_int) -> (); + fn get_use_two_sort_ids(&mut self) -> core::ffi::c_int; + fn use_two_sort_ids_on(&mut self) -> (); + fn use_two_sort_ids_off(&mut self) -> (); + fn get_tetras( + &mut self, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn add_triangles( + &mut self, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn init_tetra_traversal(&mut self) -> (); + fn get_next_tetra( + &mut self, + classification: core::ffi::c_int, + tet: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + tetScalars: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkOutEdgeIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> (); + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn get_vertex(&mut self) -> core::ffi::c_longlong; + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void; + fn has_next(&mut self) -> bool; +} +pub trait VtkOverlappingAMR { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn number_of_blanked_points(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn set_refinement_ratio( + &mut self, + level: core::ffi::c_uint, + refRatio: core::ffi::c_int, + ) -> (); + fn get_refinement_ratio(&mut self, level: core::ffi::c_uint) -> core::ffi::c_int; + fn set_amr_block_source_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + sourceId: core::ffi::c_int, + ) -> (); + fn get_amr_block_source_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> core::ffi::c_int; + fn has_children_information(&mut self) -> bool; + fn generate_parent_child_information(&mut self) -> (); + fn print_parent_child_info( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> (); + fn get_amr_info(&mut self) -> *mut core::ffi::c_void; + fn set_amr_info(&mut self, info: *mut core::ffi::c_void) -> (); + fn audit(&mut self) -> (); +} +pub trait VtkPartitionedDataSet { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_partitions(&mut self, numPartitions: core::ffi::c_uint) -> (); + fn get_number_of_partitions(&mut self) -> core::ffi::c_uint; + fn get_partition(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_partition_as_data_object( + &mut self, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn set_partition( + &mut self, + idx: core::ffi::c_uint, + partition: *mut core::ffi::c_void, + ) -> (); + fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int; + fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn remove_null_partitions(&mut self) -> (); +} +pub trait VtkPartitionedDataSetCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_partitioned_data_sets( + &mut self, + numDataSets: core::ffi::c_uint, + ) -> (); + fn get_number_of_partitioned_data_sets(&mut self) -> core::ffi::c_uint; + fn get_partitioned_data_set( + &mut self, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn set_partitioned_data_set( + &mut self, + idx: core::ffi::c_uint, + dataset: *mut core::ffi::c_void, + ) -> (); + fn remove_partitioned_data_set(&mut self, idx: core::ffi::c_uint) -> (); + fn set_partition( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + object: *mut core::ffi::c_void, + ) -> (); + fn get_partition( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn get_partition_as_data_object( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + fn get_number_of_partitions(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint; + fn set_number_of_partitions( + &mut self, + idx: core::ffi::c_uint, + numPartitions: core::ffi::c_uint, + ) -> (); + fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int; + fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn get_data_assembly(&mut self) -> *mut core::ffi::c_void; + fn set_data_assembly(&mut self, assembly: *mut core::ffi::c_void) -> (); + fn get_composite_index(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); +} +pub trait VtkPath { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + code: core::ffi::c_int, + ) -> (); + fn set_codes(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_codes(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void) -> (); + fn get_cell_points( + &mut self, + p0: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn allocate(&mut self, size: core::ffi::c_longlong, extSize: core::ffi::c_int) -> (); + fn reset(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkPentagonalPrism { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkPeriodicDataArray { + fn initialize(&mut self) -> (); + fn get_tuples( + &mut self, + ptIds: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> (); + fn squeeze(&mut self) -> (); + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn clear_lookup(&mut self) -> (); + fn get_typed_tuple( + &mut self, + idx: core::ffi::c_longlong, + t: *mut core::ffi::c_void, + ) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn resize(&mut self, numTuples: core::ffi::c_longlong) -> core::ffi::c_int; + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> (); + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_tuples( + &mut self, + dstIds: *mut core::ffi::c_void, + srcIds: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ) -> (); + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn deep_copy(&mut self, aa: *mut core::ffi::c_void) -> (); + fn remove_tuple(&mut self, id: core::ffi::c_longlong) -> (); + fn remove_first_tuple(&mut self) -> (); + fn remove_last_tuple(&mut self) -> (); + fn set_normalize(&mut self, _arg: bool) -> (); + fn get_normalize(&mut self) -> bool; +} +pub trait VtkPerlinNoise { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_frequency( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_phase( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_amplitude(&mut self, _arg: core::ffi::c_double) -> (); + fn get_amplitude(&mut self) -> core::ffi::c_double; +} +pub trait VtkPiecewiseFunction { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, f: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, f: *mut core::ffi::c_void) -> (); + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_size(&mut self) -> core::ffi::c_int; + fn add_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int; + fn remove_point_by_index(&mut self, id: usize) -> bool; + fn remove_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_int; + fn remove_all_points(&mut self) -> (); + fn add_segment( + &mut self, + x1: core::ffi::c_double, + y1: core::ffi::c_double, + x2: core::ffi::c_double, + y2: core::ffi::c_double, + ) -> (); + fn get_value(&mut self, x: core::ffi::c_double) -> core::ffi::c_double; + fn set_clamping(&mut self, _arg: core::ffi::c_int) -> (); + fn get_clamping(&mut self) -> core::ffi::c_int; + fn clamping_on(&mut self) -> (); + fn clamping_off(&mut self) -> (); + fn set_use_log_scale(&mut self, _arg: bool) -> (); + fn get_use_log_scale(&mut self) -> bool; + fn use_log_scale_on(&mut self) -> (); + fn use_log_scale_off(&mut self) -> (); + fn get_type(&mut self) -> &str; + fn get_first_non_zero_value(&mut self) -> core::ffi::c_double; + fn initialize(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn set_allow_duplicate_scalars(&mut self, _arg: core::ffi::c_int) -> (); + fn get_allow_duplicate_scalars(&mut self) -> core::ffi::c_int; + fn allow_duplicate_scalars_on(&mut self) -> (); + fn allow_duplicate_scalars_off(&mut self) -> (); + fn estimate_min_number_of_samples( + &mut self, + x1: &core::ffi::c_double, + x2: &core::ffi::c_double, + ) -> core::ffi::c_int; +} +pub trait VtkPixel { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkPixelExtent { + fn clear(&mut self) -> (); + fn empty(&mut self) -> core::ffi::c_int; + fn size(&mut self) -> usize; + fn grow(&mut self, n: core::ffi::c_int) -> (); + fn grow_low(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); + fn grow_high(&mut self, q: core::ffi::c_int, n: core::ffi::c_int) -> (); + fn shrink(&mut self, n: core::ffi::c_int) -> (); + fn shift(&mut self) -> (); + fn cell_to_node(&mut self) -> (); + fn node_to_cell(&mut self) -> (); +} +pub trait VtkPixelTransfer {} +pub trait VtkPlane { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn push(&mut self, distance: core::ffi::c_double) -> (); +} +pub trait VtkPlaneCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_items(&mut self) -> core::ffi::c_int; +} +pub trait VtkPlanes { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn set_normals(&mut self, normals: *mut core::ffi::c_void) -> (); + fn get_normals(&mut self) -> *mut core::ffi::c_void; + fn set_bounds( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ) -> (); + fn get_number_of_planes(&mut self) -> core::ffi::c_int; + fn get_plane(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; +} +pub trait VtkPlanesIntersection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_region_vertices(&mut self, pts: *mut core::ffi::c_void) -> (); + fn get_number_of_region_vertices(&mut self) -> core::ffi::c_int; + fn get_num_region_vertices(&mut self) -> core::ffi::c_int; + fn intersects_region(&mut self, R: *mut core::ffi::c_void) -> core::ffi::c_int; + fn convert_3_d_cell( + &mut self, + cell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; +} +pub trait VtkPointData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn null_point(&mut self, ptId: core::ffi::c_longlong) -> (); +} +pub trait VtkPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int; + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn find_distributed_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkPointSet { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_editable(&mut self, _arg: bool) -> (); + fn get_editable(&mut self) -> bool; + fn editable_on(&mut self) -> (); + fn editable_off(&mut self) -> (); + fn initialize(&mut self) -> (); + fn copy_structure(&mut self, pd: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn get_cell(&mut self, p0: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_points( + &mut self, + p0: core::ffi::c_longlong, + idList: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + p0: core::ffi::c_longlong, + idList: *mut core::ffi::c_void, + ) -> (); + fn get_cell_type(&mut self, p0: core::ffi::c_longlong) -> core::ffi::c_int; + fn build_point_locator(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn build_cell_locator(&mut self) -> (); + fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_point_locator(&mut self) -> *mut core::ffi::c_void; + fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_cell_locator(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn compute_bounds(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkPointSetCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkPointsProjectedHull { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn rectangle_intersection_x( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn rectangle_intersection_y( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn rectangle_intersection_z( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_size_ccw_hull_x(&mut self) -> core::ffi::c_int; + fn get_size_ccw_hull_y(&mut self) -> core::ffi::c_int; + fn get_size_ccw_hull_z(&mut self) -> core::ffi::c_int; + fn update(&mut self) -> (); +} +pub trait VtkPolyData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; + fn copy_cells( + &mut self, + pd: *mut core::ffi::c_void, + idList: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + ) -> (); + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn compute_cells_bounds(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn get_cell_id_relative_to_cell_array( + &mut self, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn set_verts(&mut self, v: *mut core::ffi::c_void) -> (); + fn get_verts(&mut self) -> *mut core::ffi::c_void; + fn set_lines(&mut self, l: *mut core::ffi::c_void) -> (); + fn get_lines(&mut self) -> *mut core::ffi::c_void; + fn set_polys(&mut self, p: *mut core::ffi::c_void) -> (); + fn get_polys(&mut self) -> *mut core::ffi::c_void; + fn set_strips(&mut self, s: *mut core::ffi::c_void) -> (); + fn get_strips(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_verts(&mut self) -> core::ffi::c_longlong; + fn get_number_of_lines(&mut self) -> core::ffi::c_longlong; + fn get_number_of_polys(&mut self) -> core::ffi::c_longlong; + fn get_number_of_strips(&mut self) -> core::ffi::c_longlong; + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool; + fn allocate_exact( + &mut self, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool; + fn allocate_copy(&mut self, pd: *mut core::ffi::c_void) -> bool; + fn allocate_proportional( + &mut self, + pd: *mut core::ffi::c_void, + ratio: core::ffi::c_double, + ) -> bool; + fn allocate( + &mut self, + numCells: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ) -> (); + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn reset(&mut self) -> (); + fn build_cells(&mut self) -> (); + fn need_to_build_cells(&mut self) -> bool; + fn build_links(&mut self, initialSize: core::ffi::c_int) -> (); + fn delete_cells(&mut self) -> (); + fn delete_links(&mut self) -> (); + fn get_cell_edge_neighbors( + &mut self, + cellId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn is_triangle( + &mut self, + v1: core::ffi::c_int, + v2: core::ffi::c_int, + v3: core::ffi::c_int, + ) -> core::ffi::c_int; + fn is_edge( + &mut self, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn is_point_used_by_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn replace_cell( + &mut self, + cellId: core::ffi::c_longlong, + ids: *mut core::ffi::c_void, + ) -> (); + fn replace_cell_point( + &mut self, + cellId: core::ffi::c_longlong, + oldPtId: core::ffi::c_longlong, + newPtId: core::ffi::c_longlong, + ) -> (); + fn reverse_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn delete_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn delete_cell(&mut self, cellId: core::ffi::c_longlong) -> (); + fn remove_deleted_cells(&mut self) -> (); + fn insert_next_linked_point( + &mut self, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_longlong; + fn remove_cell_reference(&mut self, cellId: core::ffi::c_longlong) -> (); + fn add_cell_reference(&mut self, cellId: core::ffi::c_longlong) -> (); + fn remove_reference_to_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> (); + fn add_reference_to_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> (); + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ) -> (); + fn initialize(&mut self) -> (); + fn get_piece(&mut self) -> core::ffi::c_int; + fn get_number_of_pieces(&mut self) -> core::ffi::c_int; + fn get_ghost_level(&mut self) -> core::ffi::c_int; + fn remove_ghost_cells(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_scalar_field_critical_index( + &mut self, + pointId: core::ffi::c_longlong, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkPolyDataCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, pd: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPolyLine { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn generate_sliding_normals( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkPolyPlane { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_poly_line(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_poly_line(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkPolyVertex { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkPolygon { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn compute_area(&mut self) -> core::ffi::c_double; + fn is_convex(&mut self) -> bool; + fn non_degenerate_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn bounded_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + fn get_use_mvc_interpolation(&mut self) -> bool; + fn set_use_mvc_interpolation(&mut self, _arg: bool) -> (); + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tolerance_min_value(&mut self) -> core::ffi::c_double; + fn get_tolerance_max_value(&mut self) -> core::ffi::c_double; + fn get_tolerance(&mut self) -> core::ffi::c_double; + fn ear_cut_triangulation(&mut self, measure: core::ffi::c_int) -> core::ffi::c_int; + fn unbiased_ear_cut_triangulation( + &mut self, + seed: core::ffi::c_int, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; +} +pub trait VtkPolyhedron { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn requires_initialization(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn is_primary_cell(&mut self) -> core::ffi::c_int; + fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int; + fn is_convex(&mut self) -> bool; + fn get_poly_data(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPyramid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkQuad { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticEdge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticLinearQuad { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticLinearWedge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticPolygon { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int; + fn non_degenerate_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_use_mvc_interpolation(&mut self) -> bool; + fn set_use_mvc_interpolation(&mut self, _arg: bool) -> (); +} +pub trait VtkQuadraticPyramid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticQuad { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticTetra { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticTriangle { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadraticWedge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkQuadratureSchemeDefinition { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn dictionary(&mut self) -> *mut core::ffi::c_void; + fn quadrature_offset_array_name(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn save_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int; + fn restore_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int; + fn clear(&mut self) -> (); + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_quadrature_key(&mut self) -> core::ffi::c_int; + fn get_number_of_nodes(&mut self) -> core::ffi::c_int; + fn get_number_of_quadrature_points(&mut self) -> core::ffi::c_int; +} +pub trait VtkQuadric { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_coefficients( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + a4: core::ffi::c_double, + a5: core::ffi::c_double, + a6: core::ffi::c_double, + a7: core::ffi::c_double, + a8: core::ffi::c_double, + a9: core::ffi::c_double, + ) -> (); +} +pub trait VtkRect {} +pub trait VtkRectd { + fn set( + &mut self, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + width: &core::ffi::c_double, + height: &core::ffi::c_double, + ) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: &core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn set_width(&mut self, width: &core::ffi::c_double) -> (); + fn get_width(&mut self) -> core::ffi::c_double; + fn set_height(&mut self, height: &core::ffi::c_double) -> (); + fn get_height(&mut self) -> core::ffi::c_double; + fn get_left(&mut self) -> core::ffi::c_double; + fn get_right(&mut self) -> core::ffi::c_double; + fn get_top(&mut self) -> core::ffi::c_double; + fn get_bottom(&mut self) -> core::ffi::c_double; + fn add_point(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn move_to(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn squared_norm(&mut self) -> core::ffi::c_double; +} +pub trait VtkRectf { + fn set( + &mut self, + x: &core::ffi::c_float, + y: &core::ffi::c_float, + width: &core::ffi::c_float, + height: &core::ffi::c_float, + ) -> (); + fn set_x(&mut self, x: &core::ffi::c_float) -> (); + fn get_x(&mut self) -> core::ffi::c_float; + fn set_y(&mut self, y: &core::ffi::c_float) -> (); + fn get_y(&mut self) -> core::ffi::c_float; + fn set_width(&mut self, width: &core::ffi::c_float) -> (); + fn get_width(&mut self) -> core::ffi::c_float; + fn set_height(&mut self, height: &core::ffi::c_float) -> (); + fn get_height(&mut self) -> core::ffi::c_float; + fn get_left(&mut self) -> core::ffi::c_float; + fn get_right(&mut self) -> core::ffi::c_float; + fn get_top(&mut self) -> core::ffi::c_float; + fn get_bottom(&mut self) -> core::ffi::c_float; + fn add_point(&mut self, x: core::ffi::c_float, y: core::ffi::c_float) -> (); + fn move_to(&mut self, x: core::ffi::c_float, y: core::ffi::c_float) -> (); + fn squared_norm(&mut self) -> core::ffi::c_float; +} +pub trait VtkRecti { + fn set( + &mut self, + x: &core::ffi::c_int, + y: &core::ffi::c_int, + width: &core::ffi::c_int, + height: &core::ffi::c_int, + ) -> (); + fn set_x(&mut self, x: &core::ffi::c_int) -> (); + fn get_x(&mut self) -> core::ffi::c_int; + fn set_y(&mut self, y: &core::ffi::c_int) -> (); + fn get_y(&mut self) -> core::ffi::c_int; + fn set_width(&mut self, width: &core::ffi::c_int) -> (); + fn get_width(&mut self) -> core::ffi::c_int; + fn set_height(&mut self, height: &core::ffi::c_int) -> (); + fn get_height(&mut self) -> core::ffi::c_int; + fn get_left(&mut self) -> core::ffi::c_int; + fn get_right(&mut self) -> core::ffi::c_int; + fn get_top(&mut self) -> core::ffi::c_int; + fn get_bottom(&mut self) -> core::ffi::c_int; + fn add_point(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); + fn move_to(&mut self, x: core::ffi::c_int, y: core::ffi::c_int) -> (); + fn squared_norm(&mut self) -> core::ffi::c_int; +} +pub trait VtkRectilinearGrid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn initialize(&mut self) -> (); + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn has_any_blank_points(&mut self) -> bool; + fn has_any_blank_cells(&mut self) -> bool; + fn get_points(&mut self, pnts: *mut core::ffi::c_void) -> (); + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn get_data_dimension(&mut self) -> core::ffi::c_int; + fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void; + fn set_extent( + &mut self, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn set_scalar_type( + &mut self, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> (); + fn get_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> core::ffi::c_int; + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool; + fn get_scalar_type_as_string(&mut self) -> &str; + fn set_number_of_scalar_components( + &mut self, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn has_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> bool; +} +pub trait VtkReebGraph { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn stream_triangle( + &mut self, + vertex0Id: core::ffi::c_longlong, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_longlong, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_longlong, + scalar2: core::ffi::c_double, + ) -> core::ffi::c_int; + fn stream_tetrahedron( + &mut self, + vertex0Id: core::ffi::c_longlong, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_longlong, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_longlong, + scalar2: core::ffi::c_double, + vertex3Id: core::ffi::c_longlong, + scalar3: core::ffi::c_double, + ) -> core::ffi::c_int; + fn close_stream(&mut self) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn simplify( + &mut self, + simplificationThreshold: core::ffi::c_double, + simplificationMetric: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set(&mut self, g: *mut core::ffi::c_void) -> (); +} +pub trait VtkReebGraphSimplificationMetric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_lower_bound(&mut self, _arg: core::ffi::c_double) -> (); + fn get_lower_bound(&mut self) -> core::ffi::c_double; + fn set_upper_bound(&mut self, _arg: core::ffi::c_double) -> (); + fn get_upper_bound(&mut self) -> core::ffi::c_double; + fn compute_metric( + &mut self, + mesh: *mut core::ffi::c_void, + field: *mut core::ffi::c_void, + startCriticalPoint: core::ffi::c_longlong, + vertexList: *mut core::ffi::c_void, + endCriticalPoint: core::ffi::c_longlong, + ) -> core::ffi::c_double; +} +pub trait VtkSelection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_number_of_nodes(&mut self) -> core::ffi::c_uint; + fn get_node(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void; + fn set_node(&mut self, name: &str, p1: *mut core::ffi::c_void) -> (); + fn remove_node(&mut self, idx: core::ffi::c_uint) -> (); + fn remove_all_nodes(&mut self) -> (); + fn set_expression(&mut self, _arg: &str) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn union(&mut self, selection: *mut core::ffi::c_void) -> (); + fn subtract(&mut self, selection: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn dump(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkSelectionNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn initialize(&mut self) -> (); + fn set_selection_list(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_selection_list(&mut self) -> *mut core::ffi::c_void; + fn set_selection_data(&mut self, data: *mut core::ffi::c_void) -> (); + fn get_selection_data(&mut self) -> *mut core::ffi::c_void; + fn get_properties(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn content_type(&mut self) -> *mut core::ffi::c_void; + fn set_content_type(&mut self, type_: core::ffi::c_int) -> (); + fn get_content_type(&mut self) -> core::ffi::c_int; + fn get_content_type_as_string(&mut self, type_: core::ffi::c_int) -> &str; + fn field_type(&mut self) -> *mut core::ffi::c_void; + fn set_field_type(&mut self, type_: core::ffi::c_int) -> (); + fn get_field_type(&mut self) -> core::ffi::c_int; + fn get_field_type_as_string(&mut self, type_: core::ffi::c_int) -> &str; + fn get_field_type_from_string(&mut self, type_: &str) -> core::ffi::c_int; + fn convert_selection_field_to_attribute_type( + &mut self, + val: core::ffi::c_int, + ) -> core::ffi::c_int; + fn convert_attribute_type_to_selection_field( + &mut self, + val: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_query_string(&mut self, _arg: &str) -> (); + fn epsilon(&mut self) -> *mut core::ffi::c_void; + fn zbuffer_value(&mut self) -> *mut core::ffi::c_void; + fn containing_cells(&mut self) -> *mut core::ffi::c_void; + fn connected_layers(&mut self) -> *mut core::ffi::c_void; + fn component_number(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> *mut core::ffi::c_void; + fn pixel_count(&mut self) -> *mut core::ffi::c_void; + fn source(&mut self) -> *mut core::ffi::c_void; + fn source_id(&mut self) -> *mut core::ffi::c_void; + fn prop(&mut self) -> *mut core::ffi::c_void; + fn prop_id(&mut self) -> *mut core::ffi::c_void; + fn process_id(&mut self) -> *mut core::ffi::c_void; + fn assembly_name(&mut self) -> *mut core::ffi::c_void; + fn selectors(&mut self) -> *mut core::ffi::c_void; + fn composite_index(&mut self) -> *mut core::ffi::c_void; + fn hierarchical_level(&mut self) -> *mut core::ffi::c_void; + fn hierarchical_index(&mut self) -> *mut core::ffi::c_void; + fn indexed_vertices(&mut self) -> *mut core::ffi::c_void; + fn union_selection_list(&mut self, other: *mut core::ffi::c_void) -> (); + fn subtract_selection_list(&mut self, other: *mut core::ffi::c_void) -> (); + fn equal_properties( + &mut self, + other: *mut core::ffi::c_void, + fullcompare: bool, + ) -> bool; +} +pub trait VtkSimpleCellTessellator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_generic_cell(&mut self) -> *mut core::ffi::c_void; + fn tessellate_face( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn tessellate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> (); + fn reset(&mut self) -> (); + fn initialize(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_fixed_subdivisions(&mut self) -> core::ffi::c_int; + fn get_max_subdivision_level(&mut self) -> core::ffi::c_int; + fn get_max_adaptive_subdivisions(&mut self) -> core::ffi::c_int; + fn set_fixed_subdivisions(&mut self, level: core::ffi::c_int) -> (); + fn set_max_subdivision_level(&mut self, level: core::ffi::c_int) -> (); + fn set_subdivision_levels( + &mut self, + fixed: core::ffi::c_int, + maxLevel: core::ffi::c_int, + ) -> (); +} +pub trait VtkSmoothErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_angle_tolerance(&mut self) -> core::ffi::c_double; + fn set_angle_tolerance(&mut self, value: core::ffi::c_double) -> (); +} +pub trait VtkSortFieldData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkSphere { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); +} +pub trait VtkSpheres { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_centers(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_centers(&mut self) -> *mut core::ffi::c_void; + fn set_radii(&mut self, radii: *mut core::ffi::c_void) -> (); + fn get_radii(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_spheres(&mut self) -> core::ffi::c_int; + fn get_sphere(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; +} +pub trait VtkSpline { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_parametric_range( + &mut self, + tMin: core::ffi::c_double, + tMax: core::ffi::c_double, + ) -> (); + fn set_clamp_value(&mut self, _arg: core::ffi::c_int) -> (); + fn get_clamp_value(&mut self) -> core::ffi::c_int; + fn clamp_value_on(&mut self) -> (); + fn clamp_value_off(&mut self) -> (); + fn compute(&mut self) -> (); + fn evaluate(&mut self, t: core::ffi::c_double) -> core::ffi::c_double; + fn get_number_of_points(&mut self) -> core::ffi::c_int; + fn add_point(&mut self, t: core::ffi::c_double, x: core::ffi::c_double) -> (); + fn remove_point(&mut self, t: core::ffi::c_double) -> (); + fn remove_all_points(&mut self) -> (); + fn set_closed(&mut self, _arg: core::ffi::c_int) -> (); + fn get_closed(&mut self) -> core::ffi::c_int; + fn closed_on(&mut self) -> (); + fn closed_off(&mut self) -> (); + fn set_left_constraint(&mut self, _arg: core::ffi::c_int) -> (); + fn get_left_constraint_min_value(&mut self) -> core::ffi::c_int; + fn get_left_constraint_max_value(&mut self) -> core::ffi::c_int; + fn get_left_constraint(&mut self) -> core::ffi::c_int; + fn set_right_constraint(&mut self, _arg: core::ffi::c_int) -> (); + fn get_right_constraint_min_value(&mut self) -> core::ffi::c_int; + fn get_right_constraint_max_value(&mut self) -> core::ffi::c_int; + fn get_right_constraint(&mut self) -> core::ffi::c_int; + fn set_left_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_left_value(&mut self) -> core::ffi::c_double; + fn set_right_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_right_value(&mut self) -> core::ffi::c_double; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, s: *mut core::ffi::c_void) -> (); +} +pub trait VtkStaticCellLinks { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn build_links(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_number_of_cells( + &mut self, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn initialize(&mut self) -> (); + fn squeeze(&mut self) -> (); + fn reset(&mut self) -> (); + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); +} +pub trait VtkStaticCellLinksTemplate { + fn initialize(&mut self) -> (); + fn build_links(&mut self, ds: *mut core::ffi::c_void) -> (); + fn serial_build_links( + &mut self, + numPts: core::ffi::c_longlong, + numCells: core::ffi::c_longlong, + cellArray: *mut core::ffi::c_void, + ) -> (); + fn threaded_build_links( + &mut self, + numPts: core::ffi::c_longlong, + numCells: core::ffi::c_longlong, + cellArray: *mut core::ffi::c_void, + ) -> (); + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_cells(&mut self, ptId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong; + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn set_sequential_processing(&mut self, seq: core::ffi::c_int) -> (); + fn get_sequential_processing(&mut self) -> core::ffi::c_int; +} +pub trait VtkStaticCellLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong; + fn get_large_ids(&mut self) -> bool; + fn set_use_diagonal_length_tolerance(&mut self, _arg: bool) -> (); + fn get_use_diagonal_length_tolerance(&mut self) -> bool; + fn use_diagonal_length_tolerance_on(&mut self) -> (); + fn use_diagonal_length_tolerance_off(&mut self) -> (); +} +pub trait VtkStaticEdgeLocatorTemplate {} +pub trait VtkStaticPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int; + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn initialize(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); + fn get_number_of_points_in_bucket( + &mut self, + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_bucket_ids( + &mut self, + bNum: core::ffi::c_longlong, + bList: *mut core::ffi::c_void, + ) -> (); + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong; + fn get_large_ids(&mut self) -> bool; +} +pub trait VtkStaticPointLocator2D { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int; + fn set_divisions(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> (); + fn initialize(&mut self) -> (); + fn free_search_structure(&mut self) -> (); + fn build_locator(&mut self) -> (); + fn get_number_of_points_in_bucket( + &mut self, + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_bucket_ids( + &mut self, + bNum: core::ffi::c_longlong, + bList: *mut core::ffi::c_void, + ) -> (); + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong; + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong; + fn get_large_ids(&mut self) -> bool; + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkStructuredData { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_dimension( + &mut self, + dataDescription: core::ffi::c_int, + ) -> core::ffi::c_int; + fn is_point_visible( + &mut self, + cellId: core::ffi::c_longlong, + ghosts: *mut core::ffi::c_void, + ) -> bool; +} +pub trait VtkStructuredExtent { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> (); + fn get_data_dimension(&mut self) -> core::ffi::c_int; + fn set_extent( + &mut self, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ) -> (); + fn get_extent_type(&mut self) -> core::ffi::c_int; + fn blank_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn un_blank_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn blank_cell(&mut self, ptId: core::ffi::c_longlong) -> (); + fn un_blank_cell(&mut self, ptId: core::ffi::c_longlong) -> (); + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn has_any_blank_points(&mut self) -> bool; + fn has_any_blank_cells(&mut self) -> bool; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkStructuredPoints { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; +} +pub trait VtkStructuredPointsCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkSuperquadric { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_thickness(&mut self) -> core::ffi::c_double; + fn set_thickness(&mut self, _arg: core::ffi::c_double) -> (); + fn get_thickness_min_value(&mut self) -> core::ffi::c_double; + fn get_thickness_max_value(&mut self) -> core::ffi::c_double; + fn get_phi_roundness(&mut self) -> core::ffi::c_double; + fn set_phi_roundness(&mut self, e: core::ffi::c_double) -> (); + fn get_theta_roundness(&mut self) -> core::ffi::c_double; + fn set_theta_roundness(&mut self, e: core::ffi::c_double) -> (); + fn set_size(&mut self, _arg: core::ffi::c_double) -> (); + fn get_size(&mut self) -> core::ffi::c_double; + fn toroidal_on(&mut self) -> (); + fn toroidal_off(&mut self) -> (); + fn get_toroidal(&mut self) -> core::ffi::c_int; + fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> (); +} +pub trait VtkTable { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn dump(&mut self, colWidth: core::ffi::c_uint, rowLimit: core::ffi::c_int) -> (); + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn get_row_data(&mut self) -> *mut core::ffi::c_void; + fn set_row_data(&mut self, data: *mut core::ffi::c_void) -> (); + fn get_number_of_rows(&mut self) -> core::ffi::c_longlong; + fn set_number_of_rows(&mut self, p0: core::ffi::c_longlong) -> (); + fn get_row(&mut self, row: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn set_row( + &mut self, + row: core::ffi::c_longlong, + values: *mut core::ffi::c_void, + ) -> (); + fn insert_next_blank_row( + &mut self, + default_num_val: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn insert_next_row( + &mut self, + values: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn remove_row(&mut self, row: core::ffi::c_longlong) -> (); + fn get_number_of_columns(&mut self) -> core::ffi::c_longlong; + fn get_column_name(&mut self, col: core::ffi::c_longlong) -> &str; + fn get_column_by_name(&mut self, name: &str) -> *mut core::ffi::c_void; + fn get_column(&mut self, col: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn add_column(&mut self, arr: *mut core::ffi::c_void) -> (); + fn remove_column_by_name(&mut self, name: &str) -> (); + fn remove_column(&mut self, col: core::ffi::c_longlong) -> (); + fn initialize(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; +} +pub trait VtkTetra { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkTree { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_root(&mut self) -> core::ffi::c_longlong; + fn get_number_of_children( + &mut self, + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_child( + &mut self, + v: core::ffi::c_longlong, + i: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + fn get_children( + &mut self, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> (); + fn get_parent(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_level(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn is_leaf(&mut self, vertex: core::ffi::c_longlong) -> bool; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn reorder_children( + &mut self, + parent: core::ffi::c_longlong, + children: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkTreeBFSIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkTreeDFSIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_mode(&mut self, mode: core::ffi::c_int) -> (); + fn get_mode(&mut self) -> core::ffi::c_int; +} +pub trait VtkTreeIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_tree(&mut self, tree: *mut core::ffi::c_void) -> (); + fn get_tree(&mut self) -> *mut core::ffi::c_void; + fn set_start_vertex(&mut self, vertex: core::ffi::c_longlong) -> (); + fn get_start_vertex(&mut self) -> core::ffi::c_longlong; + fn next(&mut self) -> core::ffi::c_longlong; + fn has_next(&mut self) -> bool; + fn restart(&mut self) -> (); +} +pub trait VtkTriQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkTriQuadraticPyramid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkTriangle { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn compute_area(&mut self) -> core::ffi::c_double; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); +} +pub trait VtkTriangleStrip { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkUndirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_in_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_in_edges( + &mut self, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> (); + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool; +} +pub trait VtkUniformGrid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_grid_description(&mut self) -> core::ffi::c_int; + fn blank_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn un_blank_point(&mut self, ptId: core::ffi::c_longlong) -> (); + fn blank_cell(&mut self, ptId: core::ffi::c_longlong) -> (); + fn un_blank_cell(&mut self, ptId: core::ffi::c_longlong) -> (); + fn is_point_visible(&mut self, pointId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar; + fn new_image_data_copy(&mut self) -> *mut core::ffi::c_void; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkUniformGridAMR { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new_iterator(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn set_grid_description(&mut self, gridDescription: core::ffi::c_int) -> (); + fn get_grid_description(&mut self) -> core::ffi::c_int; + fn get_number_of_levels(&mut self) -> core::ffi::c_uint; + fn get_total_number_of_blocks(&mut self) -> core::ffi::c_uint; + fn get_number_of_data_sets(&mut self, level: core::ffi::c_uint) -> core::ffi::c_uint; + fn set_data_set( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> (); + fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_composite_index( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> core::ffi::c_int; + fn get_level_and_index( + &mut self, + compositeIdx: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + idx: &mut core::ffi::c_uint, + ) -> (); + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn copy_structure(&mut self, src: *mut core::ffi::c_void) -> (); + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkUniformGridAMRDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void; + fn has_current_meta_data(&mut self) -> core::ffi::c_int; + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void; + fn get_current_flat_index(&mut self) -> core::ffi::c_uint; + fn get_current_level(&mut self) -> core::ffi::c_uint; + fn get_current_index(&mut self) -> core::ffi::c_uint; + fn go_to_first_item(&mut self) -> (); + fn go_to_next_item(&mut self) -> (); + fn is_done_with_traversal(&mut self) -> core::ffi::c_int; +} +pub trait VtkUniformHyperTreeGrid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_grid_scale( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> (); + fn set_x_coordinates(&mut self, XCoordinates: *mut core::ffi::c_void) -> (); + fn set_y_coordinates(&mut self, YCoordinates: *mut core::ffi::c_void) -> (); + fn set_z_coordinates(&mut self, ZCoordinates: *mut core::ffi::c_void) -> (); + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkUnstructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn extended_new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_data_object_type(&mut self) -> core::ffi::c_int; + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool; + fn allocate_exact( + &mut self, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool; + fn allocate( + &mut self, + numCells: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ) -> (); + fn reset(&mut self) -> (); + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> (); + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void; + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int; + fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> (); + fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void; + fn squeeze(&mut self) -> (); + fn initialize(&mut self) -> (); + fn get_max_cell_size(&mut self) -> core::ffi::c_int; + fn build_links(&mut self) -> (); + fn get_cell_links(&mut self) -> *mut core::ffi::c_void; + fn get_face_stream( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> (); + fn set_cells( + &mut self, + type_: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ) -> (); + fn get_cells(&mut self) -> *mut core::ffi::c_void; + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> (); + fn remove_reference_to_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> (); + fn add_reference_to_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> (); + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ) -> (); + fn get_piece(&mut self) -> core::ffi::c_int; + fn get_number_of_pieces(&mut self) -> core::ffi::c_int; + fn get_ghost_level(&mut self) -> core::ffi::c_int; + fn get_ids_of_cells_of_type( + &mut self, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ) -> (); + fn is_homogeneous(&mut self) -> core::ffi::c_int; + fn remove_ghost_cells(&mut self) -> (); + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_face_locations(&mut self) -> *mut core::ffi::c_void; + fn initialize_faces_representation( + &mut self, + numPrevCells: core::ffi::c_longlong, + ) -> core::ffi::c_int; + fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong; + fn decompose_a_polyhedron_cell( + &mut self, + polyhedronCellArray: *mut core::ffi::c_void, + nCellpts: &mut core::ffi::c_longlong, + nCellfaces: &mut core::ffi::c_longlong, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> (); + fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkUnstructuredGridBase { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn allocate( + &mut self, + numCells: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ) -> (); + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> (); + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + fn get_ids_of_cells_of_type( + &mut self, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ) -> (); + fn is_homogeneous(&mut self) -> core::ffi::c_int; + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; +} +pub trait VtkUnstructuredGridCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn is_done_with_traversal(&mut self) -> bool; + fn get_cell_id(&mut self) -> core::ffi::c_longlong; + fn go_to_cell(&mut self, cellId: core::ffi::c_longlong) -> (); +} +pub trait VtkVector { + fn norm(&mut self) -> core::ffi::c_double; + fn normalize(&mut self) -> core::ffi::c_double; +} +pub trait VtkVector2 {} +pub trait VtkVector2d { + fn set(&mut self, x: &core::ffi::c_double, y: &core::ffi::c_double) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: &core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn squared_norm(&mut self) -> core::ffi::c_double; +} +pub trait VtkVector2f { + fn set(&mut self, x: &core::ffi::c_float, y: &core::ffi::c_float) -> (); + fn set_x(&mut self, x: &core::ffi::c_float) -> (); + fn get_x(&mut self) -> core::ffi::c_float; + fn set_y(&mut self, y: &core::ffi::c_float) -> (); + fn get_y(&mut self) -> core::ffi::c_float; + fn squared_norm(&mut self) -> core::ffi::c_float; +} +pub trait VtkVector2i { + fn set(&mut self, x: &core::ffi::c_int, y: &core::ffi::c_int) -> (); + fn set_x(&mut self, x: &core::ffi::c_int) -> (); + fn get_x(&mut self) -> core::ffi::c_int; + fn set_y(&mut self, y: &core::ffi::c_int) -> (); + fn get_y(&mut self) -> core::ffi::c_int; + fn squared_norm(&mut self) -> core::ffi::c_int; +} +pub trait VtkVector3 {} +pub trait VtkVector3d { + fn set( + &mut self, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + z: &core::ffi::c_double, + ) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: &core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn set_z(&mut self, z: &core::ffi::c_double) -> (); + fn get_z(&mut self) -> core::ffi::c_double; + fn squared_norm(&mut self) -> core::ffi::c_double; +} +pub trait VtkVector3f { + fn set( + &mut self, + x: &core::ffi::c_float, + y: &core::ffi::c_float, + z: &core::ffi::c_float, + ) -> (); + fn set_x(&mut self, x: &core::ffi::c_float) -> (); + fn get_x(&mut self) -> core::ffi::c_float; + fn set_y(&mut self, y: &core::ffi::c_float) -> (); + fn get_y(&mut self) -> core::ffi::c_float; + fn set_z(&mut self, z: &core::ffi::c_float) -> (); + fn get_z(&mut self) -> core::ffi::c_float; + fn squared_norm(&mut self) -> core::ffi::c_float; +} +pub trait VtkVector3i { + fn set( + &mut self, + x: &core::ffi::c_int, + y: &core::ffi::c_int, + z: &core::ffi::c_int, + ) -> (); + fn set_x(&mut self, x: &core::ffi::c_int) -> (); + fn get_x(&mut self) -> core::ffi::c_int; + fn set_y(&mut self, y: &core::ffi::c_int) -> (); + fn get_y(&mut self) -> core::ffi::c_int; + fn set_z(&mut self, z: &core::ffi::c_int) -> (); + fn get_z(&mut self) -> core::ffi::c_int; + fn squared_norm(&mut self) -> core::ffi::c_int; +} +pub trait VtkVector4 {} +pub trait VtkVector4d { + fn set( + &mut self, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + z: &core::ffi::c_double, + w: &core::ffi::c_double, + ) -> (); + fn set_x(&mut self, x: &core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: &core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn set_z(&mut self, z: &core::ffi::c_double) -> (); + fn get_z(&mut self) -> core::ffi::c_double; + fn set_w(&mut self, w: &core::ffi::c_double) -> (); + fn get_w(&mut self) -> core::ffi::c_double; + fn squared_norm(&mut self) -> core::ffi::c_double; +} +pub trait VtkVector4i { + fn set( + &mut self, + x: &core::ffi::c_int, + y: &core::ffi::c_int, + z: &core::ffi::c_int, + w: &core::ffi::c_int, + ) -> (); + fn set_x(&mut self, x: &core::ffi::c_int) -> (); + fn get_x(&mut self) -> core::ffi::c_int; + fn set_y(&mut self, y: &core::ffi::c_int) -> (); + fn get_y(&mut self) -> core::ffi::c_int; + fn set_z(&mut self, z: &core::ffi::c_int) -> (); + fn get_z(&mut self) -> core::ffi::c_int; + fn set_w(&mut self, w: &core::ffi::c_int) -> (); + fn get_w(&mut self) -> core::ffi::c_int; + fn squared_norm(&mut self) -> core::ffi::c_int; +} +pub trait VtkVertex { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void; + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> (); + fn inflate(&mut self, p0: core::ffi::c_double) -> core::ffi::c_int; + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> (); + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkVertexListIterator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> (); + fn get_graph(&mut self) -> *mut core::ffi::c_void; + fn next(&mut self) -> core::ffi::c_longlong; + fn has_next(&mut self) -> bool; +} +pub trait VtkVoxel { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int; +} +pub trait VtkWedge { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn get_number_of_edges(&mut self) -> core::ffi::c_int; + fn get_number_of_faces(&mut self) -> core::ffi::c_int; + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void; + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkXMLDataElement { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_name(&mut self, _arg: &str) -> (); + fn set_id(&mut self, _arg: &str) -> (); + fn get_attribute(&mut self, name: &str) -> &str; + fn set_attribute(&mut self, name: &str, value: &str) -> (); + fn set_character_data(&mut self, data: &str, length: core::ffi::c_int) -> (); + fn add_character_data(&mut self, c: &str, length: usize) -> (); + fn get_scalar_attribute( + &mut self, + name: &str, + value: &mut core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_int_attribute(&mut self, name: &str, value: core::ffi::c_int) -> (); + fn set_float_attribute(&mut self, name: &str, value: core::ffi::c_float) -> (); + fn set_double_attribute(&mut self, name: &str, value: core::ffi::c_double) -> (); + fn set_unsigned_long_attribute( + &mut self, + name: &str, + value: core::ffi::c_ulong, + ) -> (); + fn get_word_type_attribute( + &mut self, + name: &str, + value: &mut core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_number_of_attributes(&mut self) -> core::ffi::c_int; + fn get_attribute_name(&mut self, idx: core::ffi::c_int) -> &str; + fn get_attribute_value(&mut self, idx: core::ffi::c_int) -> &str; + fn remove_attribute(&mut self, name: &str) -> (); + fn remove_all_attributes(&mut self) -> (); + fn get_parent(&mut self) -> *mut core::ffi::c_void; + fn set_parent(&mut self, parent: *mut core::ffi::c_void) -> (); + fn get_root(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_nested_elements(&mut self) -> core::ffi::c_int; + fn get_nested_element(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn add_nested_element(&mut self, element: *mut core::ffi::c_void) -> (); + fn remove_nested_element(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_all_nested_elements(&mut self) -> (); + fn find_nested_element(&mut self, id: &str) -> *mut core::ffi::c_void; + fn find_nested_element_with_name(&mut self, name: &str) -> *mut core::ffi::c_void; + fn find_nested_element_with_name_and_id( + &mut self, + name: &str, + id: &str, + ) -> *mut core::ffi::c_void; + fn find_nested_element_with_name_and_attribute( + &mut self, + name: &str, + att_name: &str, + att_value: &str, + ) -> *mut core::ffi::c_void; + fn lookup_element_with_name(&mut self, name: &str) -> *mut core::ffi::c_void; + fn lookup_element(&mut self, id: &str) -> *mut core::ffi::c_void; + fn get_xml_byte_index(&mut self) -> core::ffi::c_longlong; + fn set_xml_byte_index(&mut self, _arg: core::ffi::c_longlong) -> (); + fn is_equal_to(&mut self, elem: *mut core::ffi::c_void) -> core::ffi::c_int; + fn deep_copy(&mut self, elem: *mut core::ffi::c_void) -> (); + fn set_attribute_encoding(&mut self, _arg: core::ffi::c_int) -> (); + fn get_attribute_encoding_min_value(&mut self) -> core::ffi::c_int; + fn get_attribute_encoding_max_value(&mut self) -> core::ffi::c_int; + fn get_attribute_encoding(&mut self) -> core::ffi::c_int; + fn print_xml(&mut self, fname: &str) -> (); + fn get_character_data_width(&mut self) -> core::ffi::c_int; + fn set_character_data_width(&mut self, _arg: core::ffi::c_int) -> (); +} +impl VtkAMRDataInternals for vtkAMRDataInternals { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amr_data_internals_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amr_data_internals_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amr_data_internals_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amr_data_internals_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amr_data_internals_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amr_data_internals_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_amr_data_internals_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_amr_data_internals_initialize(self.0) } + } + fn insert(&mut self, index: core::ffi::c_uint, grid: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_amr_data_internals_insert( + sself: *mut core::ffi::c_void, + index: core::ffi::c_uint, + grid: *mut core::ffi::c_void, + ); + } + unsafe { vtk_amr_data_internals_insert(self.0, index, grid) } + } + fn get_data_set( + &mut self, + compositeIndex: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amr_data_internals_get_data_set( + sself: *mut core::ffi::c_void, + compositeIndex: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amr_data_internals_get_data_set(self.0, compositeIndex) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_amr_data_internals_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_amr_data_internals_shallow_copy(self.0, src) } + } + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_amr_data_internals_recursive_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_amr_data_internals_recursive_shallow_copy(self.0, src) } + } + fn empty(&mut self) -> bool { + unsafe extern "C" { + fn vtk_amr_data_internals_empty(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_amr_data_internals_empty(self.0) } + } + fn get_number_of_blocks(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_amr_data_internals_get_number_of_blocks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_amr_data_internals_get_number_of_blocks(self.0) } + } +} +impl VtkAdjacentVertexIterator for vtkAdjacentVertexIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_adjacent_vertex_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_adjacent_vertex_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_adjacent_vertex_iterator_new_instance(self.0) } + } + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_initialize( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ); + } + unsafe { vtk_adjacent_vertex_iterator_initialize(self.0, g, v) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_adjacent_vertex_iterator_get_graph(self.0) } + } + fn get_vertex(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_get_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_adjacent_vertex_iterator_get_vertex(self.0) } + } + fn next(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_next( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_adjacent_vertex_iterator_next(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_adjacent_vertex_iterator_has_next( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_adjacent_vertex_iterator_has_next(self.0) } + } +} +impl VtkAnimationScene for vtkAnimationScene { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_scene_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_scene_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_scene_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_scene_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_animation_scene_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_animation_scene_new(self.0) } + } + fn set_play_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_play_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_animation_scene_set_play_mode(self.0, _arg) } + } + fn set_mode_to_sequence(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_mode_to_sequence(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_set_mode_to_sequence(self.0) } + } + fn set_mode_to_real_time(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_mode_to_real_time(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_set_mode_to_real_time(self.0) } + } + fn get_play_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_scene_get_play_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_scene_get_play_mode(self.0) } + } + fn set_frame_rate(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_frame_rate( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_animation_scene_set_frame_rate(self.0, _arg) } + } + fn get_frame_rate(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_animation_scene_get_frame_rate( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_animation_scene_get_frame_rate(self.0) } + } + fn add_cue(&mut self, cue: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_animation_scene_add_cue( + sself: *mut core::ffi::c_void, + cue: *mut core::ffi::c_void, + ); + } + unsafe { vtk_animation_scene_add_cue(self.0, cue) } + } + fn remove_cue(&mut self, cue: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_animation_scene_remove_cue( + sself: *mut core::ffi::c_void, + cue: *mut core::ffi::c_void, + ); + } + unsafe { vtk_animation_scene_remove_cue(self.0, cue) } + } + fn remove_all_cues(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_remove_all_cues(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_remove_all_cues(self.0) } + } + fn get_number_of_cues(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_scene_get_number_of_cues( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_scene_get_number_of_cues(self.0) } + } + fn play(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_play(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_play(self.0) } + } + fn stop(&mut self) -> () { + unsafe extern "C" { + fn vtk_animation_scene_stop(sself: *mut core::ffi::c_void); + } + unsafe { vtk_animation_scene_stop(self.0) } + } + fn set_loop(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_loop( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_animation_scene_set_loop(self.0, _arg) } + } + fn get_loop(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_scene_get_loop( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_scene_get_loop(self.0) } + } + fn set_animation_time(&mut self, time: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_animation_time( + sself: *mut core::ffi::c_void, + time: core::ffi::c_double, + ); + } + unsafe { vtk_animation_scene_set_animation_time(self.0, time) } + } + fn set_time_mode(&mut self, mode: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_animation_scene_set_time_mode( + sself: *mut core::ffi::c_void, + mode: core::ffi::c_int, + ); + } + unsafe { vtk_animation_scene_set_time_mode(self.0, mode) } + } + fn is_in_play(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_animation_scene_is_in_play( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_animation_scene_is_in_play(self.0) } + } +} +impl VtkAnnotation for vtkAnnotation { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_new(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_annotation_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_annotation_get_data_object_type(self.0) } + } + fn get_selection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_get_selection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_get_selection(self.0) } + } + fn set_selection(&mut self, selection: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_set_selection( + sself: *mut core::ffi::c_void, + selection: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_set_selection(self.0, selection) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_get_data(self.0, info) } + } + fn label(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_label( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_label(self.0) } + } + fn color(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_color( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_color(self.0) } + } + fn opacity(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_opacity( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_opacity(self.0) } + } + fn icon_index(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_icon_index( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_icon_index(self.0) } + } + fn enable(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_enable( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_enable(self.0) } + } + fn hide(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_hide( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_hide(self.0) } + } + fn data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_data(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_annotation_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_annotation_initialize(self.0) } + } + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_shallow_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_shallow_copy(self.0, other) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_deep_copy(self.0, other) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_annotation_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_annotation_get_m_time(self.0) } + } +} +impl VtkAnnotationLayers for vtkAnnotationLayers { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_new(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_annotation_layers_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_annotation_layers_get_data_object_type(self.0) } + } + fn set_current_annotation(&mut self, ann: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_set_current_annotation( + sself: *mut core::ffi::c_void, + ann: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_set_current_annotation(self.0, ann) } + } + fn get_current_annotation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_current_annotation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_current_annotation(self.0) } + } + fn set_current_selection(&mut self, sel: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_set_current_selection( + sself: *mut core::ffi::c_void, + sel: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_set_current_selection(self.0, sel) } + } + fn get_current_selection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_current_selection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_current_selection(self.0) } + } + fn get_number_of_annotations(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_annotation_layers_get_number_of_annotations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_annotation_layers_get_number_of_annotations(self.0) } + } + fn get_annotation(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_annotation( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_annotation(self.0, idx) } + } + fn add_annotation(&mut self, ann: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_add_annotation( + sself: *mut core::ffi::c_void, + ann: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_add_annotation(self.0, ann) } + } + fn remove_annotation(&mut self, ann: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_remove_annotation( + sself: *mut core::ffi::c_void, + ann: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_remove_annotation(self.0, ann) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_annotation_layers_initialize(self.0) } + } + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_shallow_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_shallow_copy(self.0, other) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_deep_copy(self.0, other) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_get_data(self.0, info) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_annotation_layers_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_annotation_layers_get_m_time(self.0) } + } +} +impl VtkArrayData for vtkArrayData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_new_instance(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_get_data(self.0, info) } + } + fn add_array(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_array_data_add_array( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_add_array(self.0, p0) } + } + fn clear_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_array_data_clear_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_array_data_clear_arrays(self.0) } + } + fn get_number_of_arrays(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_array_data_get_number_of_arrays( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_array_data_get_number_of_arrays(self.0) } + } + fn get_array(&mut self, index: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_get_array( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_get_array(self.0, index) } + } + fn get_array_by_name(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_array_data_get_array_by_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_get_array_by_name(self.0, c_name.as_ptr()) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_array_data_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_array_data_get_data_object_type(self.0) } + } + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_array_data_shallow_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_shallow_copy(self.0, other) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_array_data_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_deep_copy(self.0, other) } + } +} +impl VtkAttributesErrorMetric for vtkAttributesErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_attributes_error_metric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_attributes_error_metric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_attributes_error_metric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_attributes_error_metric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_attributes_error_metric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_attributes_error_metric_new_instance(self.0) } + } + fn get_absolute_attribute_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_attributes_error_metric_get_absolute_attribute_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_attributes_error_metric_get_absolute_attribute_tolerance(self.0) } + } + fn set_absolute_attribute_tolerance(&mut self, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_attributes_error_metric_set_absolute_attribute_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_attributes_error_metric_set_absolute_attribute_tolerance(self.0, value) + } + } + fn get_attribute_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_attributes_error_metric_get_attribute_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_attributes_error_metric_get_attribute_tolerance(self.0) } + } + fn set_attribute_tolerance(&mut self, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_attributes_error_metric_set_attribute_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { vtk_attributes_error_metric_set_attribute_tolerance(self.0, value) } + } +} +impl VtkBSPCuts for vtkBSPCuts { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_cuts_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_cuts_get_data_object_type(self.0) } + } + fn get_kd_node_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_get_kd_node_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_get_kd_node_tree(self.0) } + } + fn get_number_of_cuts(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_cuts_get_number_of_cuts( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_cuts_get_number_of_cuts(self.0) } + } + fn equals( + &mut self, + other: *mut core::ffi::c_void, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_cuts_equals( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + tolerance: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_cuts_equals(self.0, other, tolerance) } + } + fn print_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_bsp_cuts_print_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bsp_cuts_print_tree(self.0) } + } + fn print_arrays(&mut self) -> () { + unsafe extern "C" { + fn vtk_bsp_cuts_print_arrays(sself: *mut core::ffi::c_void); + } + unsafe { vtk_bsp_cuts_print_arrays(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_cuts_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_cuts_get_data(self.0, info) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bsp_cuts_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bsp_cuts_shallow_copy(self.0, src) } + } +} +impl VtkBSPIntersections for vtkBSPIntersections { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_intersections_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_intersections_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_intersections_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_intersections_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_intersections_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_intersections_new(self.0) } + } + fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_bsp_intersections_set_cuts( + sself: *mut core::ffi::c_void, + cuts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_bsp_intersections_set_cuts(self.0, cuts) } + } + fn get_cuts(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bsp_intersections_get_cuts( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bsp_intersections_get_cuts(self.0) } + } + fn get_number_of_regions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_get_number_of_regions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bsp_intersections_get_number_of_regions(self.0) } + } + fn intersects_sphere_2( + &mut self, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_sphere_2( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_intersects_sphere_2( + self.0, + regionId, + x, + y, + z, + rSquared, + ) + } + } + fn intersects_cell( + &mut self, + regionId: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_intersects_cell( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + cell: *mut core::ffi::c_void, + cellRegion: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_intersects_cell(self.0, regionId, cell, cellRegion) + } + } + fn get_compute_intersections_using_data_bounds(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bsp_intersections_get_compute_intersections_using_data_bounds( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bsp_intersections_get_compute_intersections_using_data_bounds(self.0) + } + } + fn set_compute_intersections_using_data_bounds( + &mut self, + c: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bsp_intersections_set_compute_intersections_using_data_bounds( + sself: *mut core::ffi::c_void, + c: core::ffi::c_int, + ); + } + unsafe { + vtk_bsp_intersections_set_compute_intersections_using_data_bounds(self.0, c) + } + } + fn compute_intersections_using_data_bounds_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_bsp_intersections_compute_intersections_using_data_bounds_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bsp_intersections_compute_intersections_using_data_bounds_on(self.0) + } + } + fn compute_intersections_using_data_bounds_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_bsp_intersections_compute_intersections_using_data_bounds_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bsp_intersections_compute_intersections_using_data_bounds_off(self.0) + } + } +} +impl VtkBezierCurve for vtkBezierCurve { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_curve_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_curve_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_curve_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_curve_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_curve_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_curve_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_curve_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_curve_get_cell_type(self.0) } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_curve_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ); + } + unsafe { + vtk_bezier_curve_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_curve_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_curve_get_rational_weights(self.0) } + } +} +impl VtkBezierHexahedron for vtkBezierHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_hexahedron_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_face(self.0, faceId) } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_hexahedron_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ); + } + unsafe { + vtk_bezier_hexahedron_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_rational_weights(self.0) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_edge_cell(self.0) } + } + fn get_face_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_face_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_face_cell(self.0) } + } + fn get_interpolation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_hexahedron_get_interpolation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_hexahedron_get_interpolation(self.0) } + } +} +impl VtkBezierInterpolation for vtkBezierInterpolation { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_interpolation_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_interpolation_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_interpolation_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_interpolation_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_interpolation_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_interpolation_new_instance(self.0) } + } +} +impl VtkBezierQuadrilateral for vtkBezierQuadrilateral { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_quadrilateral_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_get_edge(self.0, edgeId) } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ); + } + unsafe { + vtk_bezier_quadrilateral_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_get_rational_weights(self.0) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_quadrilateral_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_quadrilateral_get_edge_cell(self.0) } + } +} +impl VtkBezierTetra for vtkBezierTetra { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_tetra_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_tetra_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_face(self.0, faceId) } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_tetra_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ); + } + unsafe { + vtk_bezier_tetra_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_edge_cell(self.0) } + } + fn get_face_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_face_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_face_cell(self.0) } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_tetra_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_tetra_get_rational_weights(self.0) } + } +} +impl VtkBezierTriangle for vtkBezierTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_triangle_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_get_edge(self.0, edgeId) } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_triangle_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ); + } + unsafe { + vtk_bezier_triangle_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_get_edge_cell(self.0) } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_triangle_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_triangle_get_rational_weights(self.0) } + } +} +impl VtkBezierWedge for vtkBezierWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bezier_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bezier_wedge_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_face(self.0, faceId) } + } + fn set_rational_weights_from_point_data( + &mut self, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_bezier_wedge_set_rational_weights_from_point_data( + sself: *mut core::ffi::c_void, + point_data: *mut core::ffi::c_void, + numPts: core::ffi::c_longlong, + ); + } + unsafe { + vtk_bezier_wedge_set_rational_weights_from_point_data( + self.0, + point_data, + numPts, + ) + } + } + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_boundary_quad( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_boundary_quad(self.0) } + } + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_boundary_tri( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_boundary_tri(self.0) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_edge_cell(self.0) } + } + fn get_interpolation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_interpolation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_interpolation(self.0) } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bezier_wedge_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bezier_wedge_get_rational_weights(self.0) } + } +} +impl VtkBiQuadraticQuad for vtkBiQuadraticQuad { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quad_get_face(self.0, p0) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quad_triangulate(self.0, index, ptIds, pts) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bi_quadratic_quad_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quad_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_bi_quadratic_quad_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkBiQuadraticQuadraticHexahedron for vtkBiQuadraticQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_hexahedron_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_hexahedron_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_hexahedron_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkBiQuadraticQuadraticWedge for vtkBiQuadraticQuadraticWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_quadratic_wedge_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_triangulate(self.0, index, ptIds, pts) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_quadratic_wedge_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_bi_quadratic_quadratic_wedge_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkBiQuadraticTriangle for vtkBiQuadraticTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_bi_quadratic_triangle_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_bi_quadratic_triangle_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_bi_quadratic_triangle_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_bi_quadratic_triangle_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_bi_quadratic_triangle_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkBox for vtkBox { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_box_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_box_new(self.0) } + } + fn set_x_min( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_set_x_min( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_box_set_x_min(self.0, x, y, z) } + } + fn get_x_min( + &mut self, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_get_x_min( + sself: *mut core::ffi::c_void, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, + ); + } + unsafe { vtk_box_get_x_min(self.0, x, y, z) } + } + fn set_x_max( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_set_x_max( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_box_set_x_max(self.0, x, y, z) } + } + fn get_x_max( + &mut self, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_get_x_max( + sself: *mut core::ffi::c_void, + x: &mut core::ffi::c_double, + y: &mut core::ffi::c_double, + z: &mut core::ffi::c_double, + ); + } + unsafe { vtk_box_get_x_max(self.0, x, y, z) } + } + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_set_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { vtk_box_set_bounds(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } + } + fn get_bounds( + &mut self, + xMin: &mut core::ffi::c_double, + xMax: &mut core::ffi::c_double, + yMin: &mut core::ffi::c_double, + yMax: &mut core::ffi::c_double, + zMin: &mut core::ffi::c_double, + zMax: &mut core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_box_get_bounds( + sself: *mut core::ffi::c_void, + xMin: &mut core::ffi::c_double, + xMax: &mut core::ffi::c_double, + yMin: &mut core::ffi::c_double, + yMax: &mut core::ffi::c_double, + zMin: &mut core::ffi::c_double, + zMax: &mut core::ffi::c_double, + ); + } + unsafe { vtk_box_get_bounds(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } + } +} +impl VtkCellArray for vtkCellArray { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_array_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_array_allocate(self.0, sz, ext) } + } + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_allocate_estimate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_cell_array_allocate_estimate(self.0, numCells, maxCellSize) } + } + fn allocate_exact( + &mut self, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_allocate_exact( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_cell_array_allocate_exact(self.0, numCells, connectivitySize) } + } + fn allocate_copy(&mut self, other: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_cell_array_allocate_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_allocate_copy(self.0, other) } + } + fn resize_exact( + &mut self, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_resize_exact( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_cell_array_resize_exact(self.0, numCells, connectivitySize) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_initialize(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_reset(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_squeeze(self.0) } + } + fn is_valid(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_is_valid(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_cell_array_is_valid(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_number_of_cells(self.0) } + } + fn get_number_of_offsets(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_number_of_offsets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_number_of_offsets(self.0) } + } + fn get_number_of_connectivity_ids(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_number_of_connectivity_ids( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_number_of_connectivity_ids(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_new_iterator(self.0) } + } + fn set_data( + &mut self, + offsets: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_cell_array_set_data( + sself: *mut core::ffi::c_void, + offsets: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_set_data(self.0, offsets, connectivity) } + } + fn is_storage_64_bit(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_is_storage_64_bit(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_cell_array_is_storage_64_bit(self.0) } + } + fn is_storage_shareable(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_is_storage_shareable( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_is_storage_shareable(self.0) } + } + fn use_32_bit_storage(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_use_32_bit_storage(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_use_32_bit_storage(self.0) } + } + fn use_64_bit_storage(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_use_64_bit_storage(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_use_64_bit_storage(self.0) } + } + fn use_default_storage(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_use_default_storage(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_use_default_storage(self.0) } + } + fn can_convert_to_32_bit_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_can_convert_to_32_bit_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_can_convert_to_32_bit_storage(self.0) } + } + fn can_convert_to_64_bit_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_can_convert_to_64_bit_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_can_convert_to_64_bit_storage(self.0) } + } + fn can_convert_to_default_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_can_convert_to_default_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_can_convert_to_default_storage(self.0) } + } + fn convert_to_32_bit_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_convert_to_32_bit_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_convert_to_32_bit_storage(self.0) } + } + fn convert_to_64_bit_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_convert_to_64_bit_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_convert_to_64_bit_storage(self.0) } + } + fn convert_to_default_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_convert_to_default_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_convert_to_default_storage(self.0) } + } + fn convert_to_smallest_storage(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_convert_to_smallest_storage( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_convert_to_smallest_storage(self.0) } + } + fn get_offsets_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_offsets_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_offsets_array(self.0) } + } + fn get_offsets_array_32(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_offsets_array_32( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_offsets_array_32(self.0) } + } + fn get_offsets_array_64(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_offsets_array_64( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_offsets_array_64(self.0) } + } + fn get_connectivity_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_connectivity_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_connectivity_array(self.0) } + } + fn get_connectivity_array_32(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_connectivity_array_32( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_connectivity_array_32(self.0) } + } + fn get_connectivity_array_64(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_connectivity_array_64( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_connectivity_array_64(self.0) } + } + fn is_homogeneous(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_is_homogeneous( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_is_homogeneous(self.0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_init_traversal(self.0) } + } + fn get_cell_size(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_cell_size( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_cell_size(self.0, cellId) } + } + fn insert_next_cell( + &mut self, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_insert_next_cell( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_insert_next_cell(self.0, cell) } + } + fn insert_cell_point(&mut self, id: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_array_insert_cell_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_insert_cell_point(self.0, id) } + } + fn update_cell_count(&mut self, npts: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_array_update_cell_count( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_int, + ); + } + unsafe { vtk_cell_array_update_cell_count(self.0, npts) } + } + fn get_traversal_cell_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_traversal_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_traversal_cell_id(self.0) } + } + fn set_traversal_cell_id(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_array_set_traversal_cell_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_set_traversal_cell_id(self.0, cellId) } + } + fn reverse_cell_at_id(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_array_reverse_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_reverse_cell_at_id(self.0, cellId) } + } + fn replace_cell_at_id( + &mut self, + cellId: core::ffi::c_longlong, + list: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_replace_cell_at_id( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + list: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_replace_cell_at_id(self.0, cellId, list) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_array_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_array_get_max_cell_size(self.0) } + } + fn deep_copy(&mut self, ca: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_deep_copy( + sself: *mut core::ffi::c_void, + ca: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_deep_copy(self.0, ca) } + } + fn shallow_copy(&mut self, ca: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_shallow_copy( + sself: *mut core::ffi::c_void, + ca: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_shallow_copy(self.0, ca) } + } + fn append( + &mut self, + src: *mut core::ffi::c_void, + pointOffset: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_append( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + pointOffset: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_append(self.0, src, pointOffset) } + } + fn export_legacy_format(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_export_legacy_format( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_export_legacy_format(self.0, data) } + } + fn import_legacy_format(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_import_legacy_format( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_import_legacy_format(self.0, data) } + } + fn append_legacy_format( + &mut self, + data: *mut core::ffi::c_void, + ptOffset: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_append_legacy_format( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ptOffset: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_append_legacy_format(self.0, data, ptOffset) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_cell_array_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_cell_array_get_actual_memory_size(self.0) } + } + fn set_number_of_cells(&mut self, p0: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_array_set_number_of_cells( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_set_number_of_cells(self.0, p0) } + } + fn estimate_size( + &mut self, + numCells: core::ffi::c_longlong, + maxPtsPerCell: core::ffi::c_int, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_estimate_size( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + maxPtsPerCell: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_estimate_size(self.0, numCells, maxPtsPerCell) } + } + fn get_size(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_size(self.0) } + } + fn get_number_of_connectivity_entries(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_number_of_connectivity_entries( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_number_of_connectivity_entries(self.0) } + } + fn get_insert_location(&mut self, npts: core::ffi::c_int) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_insert_location( + sself: *mut core::ffi::c_void, + npts: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_insert_location(self.0, npts) } + } + fn get_traversal_location(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_get_traversal_location( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_get_traversal_location(self.0) } + } + fn set_traversal_location(&mut self, loc: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_array_set_traversal_location( + sself: *mut core::ffi::c_void, + loc: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_set_traversal_location(self.0, loc) } + } + fn reverse_cell(&mut self, loc: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_array_reverse_cell( + sself: *mut core::ffi::c_void, + loc: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_reverse_cell(self.0, loc) } + } + fn set_cells( + &mut self, + ncells: core::ffi::c_longlong, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_array_set_cells( + sself: *mut core::ffi::c_void, + ncells: core::ffi::c_longlong, + cells: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_set_cells(self.0, ncells, cells) } + } + fn get_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_get_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_get_data(self.0) } + } +} +impl VtkCellArrayIterator for vtkCellArrayIterator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_new(self.0) } + } + fn get_cell_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_cell_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_array_iterator_get_cell_array(self.0) } + } + fn go_to_cell(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_go_to_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_array_iterator_go_to_cell(self.0, cellId) } + } + fn go_to_first_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_go_to_first_cell(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_iterator_go_to_first_cell(self.0) } + } + fn go_to_next_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_go_to_next_cell(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_array_iterator_go_to_next_cell(self.0) } + } + fn is_done_with_traversal(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_array_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_cell_array_iterator_is_done_with_traversal(self.0) } + } + fn get_current_cell_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_array_iterator_get_current_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_array_iterator_get_current_cell_id(self.0) } + } + fn replace_current_cell(&mut self, list: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_replace_current_cell( + sself: *mut core::ffi::c_void, + list: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_iterator_replace_current_cell(self.0, list) } + } + fn reverse_current_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_array_iterator_reverse_current_cell( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_array_iterator_reverse_current_cell(self.0) } + } +} +impl VtkCellData for vtkCellData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_data_new_instance(self.0) } + } +} +impl VtkCellLinks for vtkCellLinks { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_links_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_links_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_links_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_links_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_links_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_links_new_instance(self.0) } + } + fn build_links(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_links_build_links( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_links_build_links(self.0, data) } + } + fn allocate( + &mut self, + numLinks: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_allocate( + sself: *mut core::ffi::c_void, + numLinks: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_links_allocate(self.0, numLinks, ext) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_links_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_links_initialize(self.0) } + } + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_links_get_ncells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_links_get_ncells(self.0, ptId) } + } + fn insert_next_point( + &mut self, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_links_insert_next_point( + sself: *mut core::ffi::c_void, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_links_insert_next_point(self.0, numLinks) } + } + fn insert_next_cell_reference( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_insert_next_cell_reference( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_links_insert_next_cell_reference(self.0, ptId, cellId) } + } + fn delete_point(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_links_delete_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_links_delete_point(self.0, ptId) } + } + fn remove_cell_reference( + &mut self, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_remove_cell_reference( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_links_remove_cell_reference(self.0, cellId, ptId) } + } + fn add_cell_reference( + &mut self, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_add_cell_reference( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_links_add_cell_reference(self.0, cellId, ptId) } + } + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_cell_links_resize_cell_list( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ); + } + unsafe { vtk_cell_links_resize_cell_list(self.0, ptId, size) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_links_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_links_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_links_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_links_reset(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_cell_links_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_cell_links_get_actual_memory_size(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_links_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_links_deep_copy(self.0, src) } + } +} +impl VtkCellLocator for vtkCellLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_new(self.0) } + } + fn set_number_of_cells_per_bucket(&mut self, N: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_locator_set_number_of_cells_per_bucket( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + ); + } + unsafe { vtk_cell_locator_set_number_of_cells_per_bucket(self.0, N) } + } + fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_locator_get_number_of_cells_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_locator_get_number_of_cells_per_bucket(self.0) } + } + fn get_cells(&mut self, bucket: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_get_cells( + sself: *mut core::ffi::c_void, + bucket: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_get_cells(self.0, bucket) } + } + fn get_number_of_buckets(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_locator_get_number_of_buckets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_locator_get_number_of_buckets(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_free_search_structure(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_build_locator(self.0) } + } + fn build_locator_if_needed(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_build_locator_if_needed(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_build_locator_if_needed(self.0) } + } + fn force_build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_force_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_force_build_locator(self.0) } + } + fn build_locator_internal(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_locator_build_locator_internal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_locator_build_locator_internal(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_locator_generate_representation(self.0, level, pd) } + } +} +impl VtkCellLocatorStrategy for vtkCellLocatorStrategy { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_strategy_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_strategy_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_strategy_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_strategy_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_strategy_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_strategy_new_instance(self.0) } + } + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_locator_strategy_initialize( + sself: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_locator_strategy_initialize(self.0, ps) } + } + fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_locator_strategy_set_cell_locator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_locator_strategy_set_cell_locator(self.0, p0) } + } + fn get_cell_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_locator_strategy_get_cell_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_locator_strategy_get_cell_locator(self.0) } + } +} +impl VtkCellTypes for vtkCellTypes { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_new_instance(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_types_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_types_allocate(self.0, sz, ext) } + } + fn insert_cell( + &mut self, + id: core::ffi::c_longlong, + type_: core::ffi::c_uchar, + loc: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_cell_types_insert_cell( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + type_: core::ffi::c_uchar, + loc: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_types_insert_cell(self.0, id, type_, loc) } + } + fn insert_next_cell( + &mut self, + type_: core::ffi::c_uchar, + loc: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_types_insert_next_cell( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_uchar, + loc: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_types_insert_next_cell(self.0, type_, loc) } + } + fn set_cell_types( + &mut self, + ncells: core::ffi::c_longlong, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cell_types_set_cell_types( + sself: *mut core::ffi::c_void, + ncells: core::ffi::c_longlong, + cellTypes: *mut core::ffi::c_void, + cellLocations: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_cell_types_set_cell_types(self.0, ncells, cellTypes, cellLocations) + } + } + fn get_cell_location( + &mut self, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_types_get_cell_location( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_types_get_cell_location(self.0, cellId) } + } + fn delete_cell(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_cell_types_delete_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_cell_types_delete_cell(self.0, cellId) } + } + fn get_number_of_types(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_types_get_number_of_types( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_types_get_number_of_types(self.0) } + } + fn is_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_types_is_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_types_is_type(self.0, type_) } + } + fn insert_next_type(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_cell_types_insert_next_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_uchar, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_cell_types_insert_next_type(self.0, type_) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_cell_types_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_cell_types_get_cell_type(self.0, cellId) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_types_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_types_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_types_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cell_types_reset(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_cell_types_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_cell_types_get_actual_memory_size(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_cell_types_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_types_deep_copy(self.0, src) } + } + fn get_class_name_from_type_id(&mut self, typeId: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_cell_types_get_class_name_from_type_id( + sself: *mut core::ffi::c_void, + typeId: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_cell_types_get_class_name_from_type_id(self.0, typeId) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_type_id_from_class_name(&mut self, classname: &str) -> core::ffi::c_int { + let c_classname = std::ffi::CString::new(classname) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_cell_types_get_type_id_from_class_name( + sself: *mut core::ffi::c_void, + classname: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_cell_types_get_type_id_from_class_name(self.0, c_classname.as_ptr()) + } + } + fn is_linear(&mut self, type_: core::ffi::c_uchar) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_types_is_linear( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_uchar, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_types_is_linear(self.0, type_) } + } + fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_get_cell_types_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_get_cell_types_array(self.0) } + } + fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_types_get_cell_locations_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_types_get_cell_locations_array(self.0) } + } +} +impl VtkClosestNPointsStrategy for vtkClosestNPointsStrategy { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_n_points_strategy_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_n_points_strategy_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_n_points_strategy_new_instance(self.0) } + } + fn set_closest_n_points(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_set_closest_n_points( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_closest_n_points_strategy_set_closest_n_points(self.0, _arg) } + } + fn get_closest_n_points_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_get_closest_n_points_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_closest_n_points_strategy_get_closest_n_points_min_value(self.0) } + } + fn get_closest_n_points_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_get_closest_n_points_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_closest_n_points_strategy_get_closest_n_points_max_value(self.0) } + } + fn get_closest_n_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_closest_n_points_strategy_get_closest_n_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_closest_n_points_strategy_get_closest_n_points(self.0) } + } +} +impl VtkClosestPointStrategy for vtkClosestPointStrategy { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_point_strategy_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_point_strategy_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_point_strategy_new_instance(self.0) } + } + fn initialize(&mut self, ps: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_closest_point_strategy_initialize( + sself: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_closest_point_strategy_initialize(self.0, ps) } + } + fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_closest_point_strategy_set_point_locator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_closest_point_strategy_set_point_locator(self.0, p0) } + } + fn get_point_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_get_point_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_closest_point_strategy_get_point_locator(self.0) } + } + fn select_cell( + &mut self, + self_: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_closest_point_strategy_select_cell( + sself: *mut core::ffi::c_void, + self_: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + cell: *mut core::ffi::c_void, + gencell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_closest_point_strategy_select_cell(self.0, self_, cellId, cell, gencell) + } + } +} +impl VtkCone for vtkCone { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_new_instance(self.0) } + } + fn set_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cone_set_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cone_set_angle(self.0, _arg) } + } + fn get_angle_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_get_angle_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_get_angle_min_value(self.0) } + } + fn get_angle_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_get_angle_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_get_angle_max_value(self.0) } + } + fn get_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_get_angle(sself: *mut core::ffi::c_void) -> core::ffi::c_double; + } + unsafe { vtk_cone_get_angle(self.0) } + } +} +impl VtkConvexPointSet for vtkConvexPointSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_new_instance(self.0) } + } + fn has_fixed_topology(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_has_fixed_topology( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_has_fixed_topology(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_get_cell_type(self.0) } + } + fn requires_initialization(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_requires_initialization( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_requires_initialization(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_get_number_of_edges(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_get_edge(self.0, p0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_get_number_of_faces(self.0) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_convex_point_set_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_convex_point_set_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_convex_point_set_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_convex_point_set_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_convex_point_set_clip( + self.0, + value, + cellScalars, + locator, + connectivity, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_triangulate(self.0, index, ptIds, pts) } + } + fn is_primary_cell(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_convex_point_set_is_primary_cell( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_convex_point_set_is_primary_cell(self.0) } + } +} +impl VtkCubicLine for vtkCubicLine { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cubic_line_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cubic_line_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_cubic_line_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cubic_line_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cubic_line_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_cubic_line_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_cubic_line_clip( + self.0, + value, + cellScalars, + locator, + lines, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkCylinder for vtkCylinder { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_axis( + &mut self, + ax: core::ffi::c_double, + ay: core::ffi::c_double, + az: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_set_axis( + sself: *mut core::ffi::c_void, + ax: core::ffi::c_double, + ay: core::ffi::c_double, + az: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_set_axis(self.0, ax, ay, az) } + } +} +impl VtkDataAssembly for vtkDataAssembly { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_assembly_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_assembly_initialize(self.0) } + } + fn initialize_from_xml(&mut self, xmlcontents: &str) -> bool { + let c_xmlcontents = std::ffi::CString::new(xmlcontents) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_initialize_from_xml( + sself: *mut core::ffi::c_void, + xmlcontents: *const core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_initialize_from_xml(self.0, c_xmlcontents.as_ptr()) } + } + fn get_root_node(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_root_node( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_root_node(self.0) } + } + fn set_root_node_name(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_set_root_node_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_data_assembly_set_root_node_name(self.0, c_name.as_ptr()) } + } + fn get_root_node_name(&mut self) -> &str { + unsafe extern "C" { + fn vtk_data_assembly_get_root_node_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_data_assembly_get_root_node_name(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn add_node(&mut self, name: &str, parent: core::ffi::c_int) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_add_node( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + parent: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_add_node(self.0, c_name.as_ptr(), parent) } + } + fn add_subtree( + &mut self, + parent: core::ffi::c_int, + other: *mut core::ffi::c_void, + otherParent: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_add_subtree( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + other: *mut core::ffi::c_void, + otherParent: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_add_subtree(self.0, parent, other, otherParent) } + } + fn remove_node(&mut self, id: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_remove_node( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_data_assembly_remove_node(self.0, id) } + } + fn set_node_name(&mut self, id: core::ffi::c_int, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_set_node_name( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_data_assembly_set_node_name(self.0, id, c_name.as_ptr()) } + } + fn get_node_name(&mut self, id: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_data_assembly_get_node_name( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_data_assembly_get_node_name(self.0, id) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_first_node_by_path(&mut self, path: &str) -> core::ffi::c_int { + let c_path = std::ffi::CString::new(path).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_get_first_node_by_path( + sself: *mut core::ffi::c_void, + path: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_first_node_by_path(self.0, c_path.as_ptr()) } + } + fn add_data_set_index( + &mut self, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_add_data_set_index( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool; + } + unsafe { vtk_data_assembly_add_data_set_index(self.0, id, dataset_index) } + } + fn add_data_set_index_range( + &mut self, + id: core::ffi::c_int, + index_start: core::ffi::c_uint, + count: core::ffi::c_int, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_add_data_set_index_range( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + index_start: core::ffi::c_uint, + count: core::ffi::c_int, + ) -> bool; + } + unsafe { + vtk_data_assembly_add_data_set_index_range(self.0, id, index_start, count) + } + } + fn remove_data_set_index( + &mut self, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_remove_data_set_index( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + dataset_index: core::ffi::c_uint, + ) -> bool; + } + unsafe { vtk_data_assembly_remove_data_set_index(self.0, id, dataset_index) } + } + fn remove_all_data_set_indices( + &mut self, + id: core::ffi::c_int, + traverse_subtree: bool, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_remove_all_data_set_indices( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + traverse_subtree: bool, + ) -> bool; + } + unsafe { + vtk_data_assembly_remove_all_data_set_indices(self.0, id, traverse_subtree) + } + } + fn find_first_node_with_name( + &mut self, + name: &str, + traversal_order: core::ffi::c_int, + ) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_find_first_node_with_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + traversal_order: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_assembly_find_first_node_with_name( + self.0, + c_name.as_ptr(), + traversal_order, + ) + } + } + fn get_number_of_children(&mut self, parent: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_number_of_children( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_number_of_children(self.0, parent) } + } + fn get_child( + &mut self, + parent: core::ffi::c_int, + index: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_child( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_child(self.0, parent, index) } + } + fn get_child_index( + &mut self, + parent: core::ffi::c_int, + child: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_child_index( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_int, + child: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_child_index(self.0, parent, child) } + } + fn get_parent(&mut self, id: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_assembly_get_parent( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_assembly_get_parent(self.0, id) } + } + fn has_attribute(&mut self, id: core::ffi::c_int, name: &str) -> bool { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_has_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: *const core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_has_attribute(self.0, id, c_name.as_ptr()) } + } + fn set_attribute(&mut self, id: core::ffi::c_int, name: &str, value: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_set_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: *const core::ffi::c_char, + value: *const core::ffi::c_char, + ); + } + unsafe { + vtk_data_assembly_set_attribute( + self.0, + id, + c_name.as_ptr(), + c_value.as_ptr(), + ) + } + } + fn get_attribute(&mut self, id: core::ffi::c_int, name: &str, value: &str) -> bool { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_get_attribute( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: *const core::ffi::c_char, + value: *const core::ffi::c_char, + ) -> bool; + } + unsafe { + vtk_data_assembly_get_attribute( + self.0, + id, + c_name.as_ptr(), + c_value.as_ptr(), + ) + } + } + fn get_attribute_or_default( + &mut self, + id: core::ffi::c_int, + name: &str, + default_value: &str, + ) -> &str { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_default_value = std::ffi::CString::new(default_value) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_get_attribute_or_default( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + name: *const core::ffi::c_char, + default_value: *const core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_data_assembly_get_attribute_or_default( + self.0, + id, + c_name.as_ptr(), + c_default_value.as_ptr(), + ) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn visit( + &mut self, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_assembly_visit( + sself: *mut core::ffi::c_void, + visitor: *mut core::ffi::c_void, + traversal_order: core::ffi::c_int, + ); + } + unsafe { vtk_data_assembly_visit(self.0, visitor, traversal_order) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_assembly_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_assembly_deep_copy(self.0, other) } + } + fn is_node_name_valid(&mut self, name: &str) -> bool { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_is_node_name_valid( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_is_node_name_valid(self.0, c_name.as_ptr()) } + } + fn is_node_name_reserved(&mut self, name: &str) -> bool { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_assembly_is_node_name_reserved( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> bool; + } + unsafe { vtk_data_assembly_is_node_name_reserved(self.0, c_name.as_ptr()) } + } +} +impl VtkDataAssemblyUtilities for vtkDataAssemblyUtilities { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_utilities_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_utilities_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_utilities_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_utilities_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_assembly_utilities_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_assembly_utilities_new_instance(self.0) } + } + fn hierarchy_name(&mut self) -> &str { + unsafe extern "C" { + fn vtk_data_assembly_utilities_hierarchy_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_data_assembly_utilities_hierarchy_name(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn generate_hierarchy( + &mut self, + input: *mut core::ffi::c_void, + hierarchy: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_data_assembly_utilities_generate_hierarchy( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + hierarchy: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_data_assembly_utilities_generate_hierarchy( + self.0, + input, + hierarchy, + output, + ) + } + } +} +impl VtkDataObject for vtkDataObject { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_new_instance(self.0) } + } + fn get_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_information(self.0) } + } + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_set_information( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_set_information(self.0, p0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_data_object_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_data_object_get_m_time(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_object_initialize(self.0) } + } + fn release_data(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_release_data(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_object_release_data(self.0) } + } + fn get_data_released(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_data_released( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_data_released(self.0) } + } + fn set_global_release_data_flag(&mut self, val: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_object_set_global_release_data_flag( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ); + } + unsafe { vtk_data_object_set_global_release_data_flag(self.0, val) } + } + fn global_release_data_flag_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_global_release_data_flag_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_global_release_data_flag_on(self.0) } + } + fn global_release_data_flag_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_global_release_data_flag_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_global_release_data_flag_off(self.0) } + } + fn get_global_release_data_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_global_release_data_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_global_release_data_flag(self.0) } + } + fn set_field_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_set_field_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_set_field_data(self.0, p0) } + } + fn get_field_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_field_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_field_data(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_data_object_type(self.0) } + } + fn get_update_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_data_object_get_update_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_data_object_get_update_time(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_data_object_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_data_object_get_actual_memory_size(self.0) } + } + fn copy_information_from_pipeline(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_copy_information_from_pipeline( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_copy_information_from_pipeline(self.0, info) } + } + fn copy_information_to_pipeline(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_copy_information_to_pipeline( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_copy_information_to_pipeline(self.0, info) } + } + fn get_active_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_active_field_information( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_data_object_get_active_field_information( + self.0, + info, + fieldAssociation, + attributeType, + ) + } + } + fn get_named_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: &str, + ) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_object_get_named_field_information( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_data_object_get_named_field_information( + self.0, + info, + fieldAssociation, + c_name.as_ptr(), + ) + } + } + fn remove_named_field_information( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: &str, + ) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_object_remove_named_field_information( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + name: *const core::ffi::c_char, + ); + } + unsafe { + vtk_data_object_remove_named_field_information( + self.0, + info, + fieldAssociation, + c_name.as_ptr(), + ) + } + } + fn set_active_attribute( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeName: &str, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + let c_attributeName = std::ffi::CString::new(attributeName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_object_set_active_attribute( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeName: *const core::ffi::c_char, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_data_object_set_active_attribute( + self.0, + info, + fieldAssociation, + c_attributeName.as_ptr(), + attributeType, + ) + } + } + fn set_active_attribute_info( + &mut self, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + name: &str, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + numTuples: core::ffi::c_int, + ) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_object_set_active_attribute_info( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + fieldAssociation: core::ffi::c_int, + attributeType: core::ffi::c_int, + name: *const core::ffi::c_char, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + numTuples: core::ffi::c_int, + ); + } + unsafe { + vtk_data_object_set_active_attribute_info( + self.0, + info, + fieldAssociation, + attributeType, + c_name.as_ptr(), + arrayType, + numComponents, + numTuples, + ) + } + } + fn set_point_data_active_scalar_info( + &mut self, + info: *mut core::ffi::c_void, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_object_set_point_data_active_scalar_info( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + arrayType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ); + } + unsafe { + vtk_data_object_set_point_data_active_scalar_info( + self.0, + info, + arrayType, + numComponents, + ) + } + } + fn data_has_been_generated(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_data_has_been_generated(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_object_data_has_been_generated(self.0) } + } + fn prepare_for_new_data(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_prepare_for_new_data(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_object_prepare_for_new_data(self.0) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_shallow_copy(self.0, src) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_deep_copy(self.0, src) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_extent_type(self.0) } + } + fn get_attributes(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_attributes( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_attributes(self.0, type_) } + } + fn get_ghost_array(&mut self, type_: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_ghost_array( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_ghost_array(self.0, type_) } + } + fn get_attributes_as_field_data( + &mut self, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_attributes_as_field_data( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_attributes_as_field_data(self.0, type_) } + } + fn get_attribute_type_for_array( + &mut self, + arr: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_get_attribute_type_for_array( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_get_attribute_type_for_array(self.0, arr) } + } + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_data_object_get_number_of_elements( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_data_object_get_number_of_elements(self.0, type_) } + } + fn get_association_type_as_string( + &mut self, + associationType: core::ffi::c_int, + ) -> &str { + unsafe extern "C" { + fn vtk_data_object_get_association_type_as_string( + sself: *mut core::ffi::c_void, + associationType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_data_object_get_association_type_as_string(self.0, associationType) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_association_type_from_string( + &mut self, + associationName: &str, + ) -> core::ffi::c_int { + let c_associationName = std::ffi::CString::new(associationName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_object_get_association_type_from_string( + sself: *mut core::ffi::c_void, + associationName: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_object_get_association_type_from_string( + self.0, + c_associationName.as_ptr(), + ) + } + } + fn data_type_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_type_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_type_name(self.0) } + } + fn data_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_object(self.0) } + } + fn data_extent_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_extent_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_extent_type(self.0) } + } + fn data_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_extent(self.0) } + } + fn all_pieces_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_all_pieces_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_all_pieces_extent(self.0) } + } + fn data_piece_number(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_piece_number( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_piece_number(self.0) } + } + fn data_number_of_pieces(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_number_of_pieces(self.0) } + } + fn data_number_of_ghost_levels(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_number_of_ghost_levels( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_number_of_ghost_levels(self.0) } + } + fn data_time_step(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_data_time_step( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_data_time_step(self.0) } + } + fn point_data_vector(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_point_data_vector( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_point_data_vector(self.0) } + } + fn cell_data_vector(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_cell_data_vector( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_cell_data_vector(self.0) } + } + fn vertex_data_vector(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_vertex_data_vector( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_vertex_data_vector(self.0) } + } + fn edge_data_vector(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_edge_data_vector( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_edge_data_vector(self.0) } + } + fn field_array_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_array_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_array_type(self.0) } + } + fn field_association(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_association( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_association(self.0) } + } + fn field_attribute_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_attribute_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_attribute_type(self.0) } + } + fn field_active_attribute(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_active_attribute( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_active_attribute(self.0) } + } + fn field_number_of_components(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_number_of_components( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_number_of_components(self.0) } + } + fn field_number_of_tuples(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_number_of_tuples( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_number_of_tuples(self.0) } + } + fn field_operation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_operation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_operation(self.0) } + } + fn field_range(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_range(self.0) } + } + fn piece_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_piece_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_piece_extent(self.0) } + } + fn field_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_field_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_field_name(self.0) } + } + fn origin(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_origin( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_origin(self.0) } + } + fn spacing(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_spacing( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_spacing(self.0) } + } + fn direction(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_direction( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_direction(self.0) } + } + fn bounding_box(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_bounding_box( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_bounding_box(self.0) } + } + fn sil(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_sil( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_sil(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_get_data(self.0, info) } + } +} +impl VtkDataObjectCollection for vtkDataObjectCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_get_next_item(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_collection_get_item(self.0, i) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_collection_get_number_of_items(self.0) } + } +} +impl VtkDataObjectTreeIterator for vtkDataObjectTreeIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_new_instance(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_go_to_first_item( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_go_to_next_item( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_tree_iterator_is_done_with_traversal(self.0) } + } + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_current_data_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_get_current_data_object(self.0) } + } + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_current_meta_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_tree_iterator_get_current_meta_data(self.0) } + } + fn has_current_meta_data(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_has_current_meta_data( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_tree_iterator_has_current_meta_data(self.0) } + } + fn get_current_flat_index(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_current_flat_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_data_object_tree_iterator_get_current_flat_index(self.0) } + } + fn set_visit_only_leaves(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_set_visit_only_leaves( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_data_object_tree_iterator_set_visit_only_leaves(self.0, _arg) } + } + fn get_visit_only_leaves(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_visit_only_leaves( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_tree_iterator_get_visit_only_leaves(self.0) } + } + fn visit_only_leaves_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_visit_only_leaves_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_visit_only_leaves_on(self.0) } + } + fn visit_only_leaves_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_visit_only_leaves_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_visit_only_leaves_off(self.0) } + } + fn set_traverse_sub_tree(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_set_traverse_sub_tree( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_data_object_tree_iterator_set_traverse_sub_tree(self.0, _arg) } + } + fn get_traverse_sub_tree(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_get_traverse_sub_tree( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_tree_iterator_get_traverse_sub_tree(self.0) } + } + fn traverse_sub_tree_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_traverse_sub_tree_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_traverse_sub_tree_on(self.0) } + } + fn traverse_sub_tree_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_object_tree_iterator_traverse_sub_tree_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_tree_iterator_traverse_sub_tree_off(self.0) } + } +} +impl VtkDataObjectTypes for vtkDataObjectTypes { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_types_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_types_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_types_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_new_instance(self.0) } + } + fn get_class_name_from_type_id(&mut self, typeId: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_data_object_types_get_class_name_from_type_id( + sself: *mut core::ffi::c_void, + typeId: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_data_object_types_get_class_name_from_type_id(self.0, typeId) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_type_id_from_class_name(&mut self, classname: &str) -> core::ffi::c_int { + let c_classname = std::ffi::CString::new(classname) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_object_types_get_type_id_from_class_name( + sself: *mut core::ffi::c_void, + classname: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_object_types_get_type_id_from_class_name( + self.0, + c_classname.as_ptr(), + ) + } + } + fn new_data_object(&mut self, classname: &str) -> *mut core::ffi::c_void { + let c_classname = std::ffi::CString::new(classname) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_object_types_new_data_object( + sself: *mut core::ffi::c_void, + classname: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_types_new_data_object(self.0, c_classname.as_ptr()) } + } + fn type_id_is_a( + &mut self, + typeId: core::ffi::c_int, + targetTypeId: core::ffi::c_int, + ) -> bool { + unsafe extern "C" { + fn vtk_data_object_types_type_id_is_a( + sself: *mut core::ffi::c_void, + typeId: core::ffi::c_int, + targetTypeId: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_data_object_types_type_id_is_a(self.0, typeId, targetTypeId) } + } + fn get_common_base_type_id( + &mut self, + typeA: core::ffi::c_int, + typeB: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_object_types_get_common_base_type_id( + sself: *mut core::ffi::c_void, + typeA: core::ffi::c_int, + typeB: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_object_types_get_common_base_type_id(self.0, typeA, typeB) } + } +} +impl VtkDataSetAttributes for vtkDataSetAttributes { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_initialize(self.0) } + } + fn update(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_update(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_update(self.0) } + } + fn deep_copy(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_deep_copy( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_deep_copy(self.0, pd) } + } + fn shallow_copy(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_shallow_copy( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_shallow_copy(self.0, pd) } + } + fn ghost_array_name(&mut self) -> &str { + unsafe extern "C" { + fn vtk_data_set_attributes_ghost_array_name( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_data_set_attributes_ghost_array_name(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_scalars(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_scalars( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_scalars(self.0, da) } + } + fn set_active_scalars(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_scalars( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_scalars(self.0, c_name.as_ptr()) } + } + fn get_scalars(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_scalars( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_scalars(self.0) } + } + fn set_vectors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_vectors( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_vectors(self.0, da) } + } + fn set_active_vectors(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_vectors( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_vectors(self.0, c_name.as_ptr()) } + } + fn get_vectors(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_vectors( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_vectors(self.0) } + } + fn set_normals(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_normals( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_normals(self.0, da) } + } + fn set_active_normals(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_normals( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_normals(self.0, c_name.as_ptr()) } + } + fn get_normals(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_normals( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_normals(self.0) } + } + fn set_tangents(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_tangents( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_tangents(self.0, da) } + } + fn set_active_tangents(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_tangents( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_tangents(self.0, c_name.as_ptr()) } + } + fn get_tangents(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_tangents( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_tangents(self.0) } + } + fn set_t_coords(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_t_coords( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_t_coords(self.0, da) } + } + fn set_active_t_coords(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_t_coords( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_t_coords(self.0, c_name.as_ptr()) } + } + fn get_t_coords(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_t_coords( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_t_coords(self.0) } + } + fn set_tensors(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_tensors( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_tensors(self.0, da) } + } + fn set_active_tensors(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_tensors( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_tensors(self.0, c_name.as_ptr()) } + } + fn get_tensors(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_tensors( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_tensors(self.0) } + } + fn set_global_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_global_ids( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_global_ids(self.0, da) } + } + fn set_active_global_ids(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_global_ids( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_active_global_ids(self.0, c_name.as_ptr()) } + } + fn get_global_ids(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_global_ids( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_global_ids(self.0) } + } + fn set_pedigree_ids(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_pedigree_ids( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_pedigree_ids(self.0, da) } + } + fn set_active_pedigree_ids(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_pedigree_ids( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_set_attributes_set_active_pedigree_ids(self.0, c_name.as_ptr()) + } + } + fn get_pedigree_ids(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_pedigree_ids( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_pedigree_ids(self.0) } + } + fn set_rational_weights(&mut self, da: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_rational_weights( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_rational_weights(self.0, da) } + } + fn set_active_rational_weights(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_rational_weights( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_set_attributes_set_active_rational_weights(self.0, c_name.as_ptr()) + } + } + fn get_rational_weights(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_rational_weights( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_rational_weights(self.0) } + } + fn set_higher_order_degrees( + &mut self, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_higher_order_degrees( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_higher_order_degrees(self.0, da) } + } + fn set_active_higher_order_degrees(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_higher_order_degrees( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_set_attributes_set_active_higher_order_degrees( + self.0, + c_name.as_ptr(), + ) + } + } + fn get_higher_order_degrees(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_higher_order_degrees( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_higher_order_degrees(self.0) } + } + fn set_active_attribute( + &mut self, + name: &str, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_data_set_attributes_set_active_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_data_set_attributes_set_active_attribute( + self.0, + c_name.as_ptr(), + attributeType, + ) + } + } + fn is_array_an_attribute(&mut self, idx: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_is_array_an_attribute( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_is_array_an_attribute(self.0, idx) } + } + fn set_attribute( + &mut self, + aa: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_set_attribute( + sself: *mut core::ffi::c_void, + aa: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_set_attribute(self.0, aa, attributeType) } + } + fn get_attribute( + &mut self, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_attribute( + sself: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_attribute(self.0, attributeType) } + } + fn get_abstract_attribute( + &mut self, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_attributes_get_abstract_attribute( + sself: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_attributes_get_abstract_attribute(self.0, attributeType) } + } + fn get_attribute_type_as_string(&mut self, attributeType: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_data_set_attributes_get_attribute_type_as_string( + sself: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_data_set_attributes_get_attribute_type_as_string(self.0, attributeType) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_long_attribute_type_as_string( + &mut self, + attributeType: core::ffi::c_int, + ) -> &str { + unsafe extern "C" { + fn vtk_data_set_attributes_get_long_attribute_type_as_string( + sself: *mut core::ffi::c_void, + attributeType: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_data_set_attributes_get_long_attribute_type_as_string( + self.0, + attributeType, + ) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_copy_attribute( + &mut self, + index: core::ffi::c_int, + value: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_attribute( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + value: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { + vtk_data_set_attributes_set_copy_attribute(self.0, index, value, ctype) + } + } + fn get_copy_attribute( + &mut self, + index: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_attribute( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_attribute(self.0, index, ctype) } + } + fn set_copy_scalars(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_scalars( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_scalars(self.0, i, ctype) } + } + fn get_copy_scalars(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_scalars( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_scalars(self.0, ctype) } + } + fn copy_scalars_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_scalars_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_scalars_on(self.0) } + } + fn copy_scalars_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_scalars_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_scalars_off(self.0) } + } + fn set_copy_vectors(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_vectors( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_vectors(self.0, i, ctype) } + } + fn get_copy_vectors(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_vectors( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_vectors(self.0, ctype) } + } + fn copy_vectors_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_vectors_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_vectors_on(self.0) } + } + fn copy_vectors_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_vectors_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_vectors_off(self.0) } + } + fn set_copy_normals(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_normals( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_normals(self.0, i, ctype) } + } + fn get_copy_normals(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_normals( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_normals(self.0, ctype) } + } + fn copy_normals_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_normals_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_normals_on(self.0) } + } + fn copy_normals_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_normals_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_normals_off(self.0) } + } + fn set_copy_tangents(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_tangents( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_tangents(self.0, i, ctype) } + } + fn get_copy_tangents(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_tangents( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_tangents(self.0, ctype) } + } + fn copy_tangents_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tangents_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_tangents_on(self.0) } + } + fn copy_tangents_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tangents_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_tangents_off(self.0) } + } + fn set_copy_t_coords(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_t_coords( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_t_coords(self.0, i, ctype) } + } + fn get_copy_t_coords(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_t_coords( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_t_coords(self.0, ctype) } + } + fn copy_t_coords_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_t_coords_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_t_coords_on(self.0) } + } + fn copy_t_coords_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_t_coords_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_t_coords_off(self.0) } + } + fn set_copy_tensors(&mut self, i: core::ffi::c_int, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_tensors( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_tensors(self.0, i, ctype) } + } + fn get_copy_tensors(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_tensors( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_tensors(self.0, ctype) } + } + fn copy_tensors_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tensors_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_tensors_on(self.0) } + } + fn copy_tensors_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tensors_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_tensors_off(self.0) } + } + fn set_copy_global_ids( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_global_ids( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_global_ids(self.0, i, ctype) } + } + fn get_copy_global_ids(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_global_ids( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_global_ids(self.0, ctype) } + } + fn copy_global_ids_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_global_ids_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_data_set_attributes_copy_global_ids_on(self.0) } + } + fn copy_global_ids_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_global_ids_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_global_ids_off(self.0) } + } + fn set_copy_pedigree_ids( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_pedigree_ids( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_pedigree_ids(self.0, i, ctype) } + } + fn get_copy_pedigree_ids(&mut self, ctype: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_pedigree_ids( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_pedigree_ids(self.0, ctype) } + } + fn copy_pedigree_ids_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_pedigree_ids_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_pedigree_ids_on(self.0) } + } + fn copy_pedigree_ids_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_pedigree_ids_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_pedigree_ids_off(self.0) } + } + fn set_copy_rational_weights( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_rational_weights( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_set_copy_rational_weights(self.0, i, ctype) } + } + fn get_copy_rational_weights( + &mut self, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_rational_weights( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_rational_weights(self.0, ctype) } + } + fn copy_rational_weights_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_rational_weights_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_rational_weights_on(self.0) } + } + fn copy_rational_weights_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_rational_weights_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_rational_weights_off(self.0) } + } + fn set_copy_higher_order_degrees( + &mut self, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_set_copy_higher_order_degrees( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ctype: core::ffi::c_int, + ); + } + unsafe { + vtk_data_set_attributes_set_copy_higher_order_degrees(self.0, i, ctype) + } + } + fn get_copy_higher_order_degrees( + &mut self, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_attributes_get_copy_higher_order_degrees( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_attributes_get_copy_higher_order_degrees(self.0, ctype) } + } + fn copy_higher_order_degrees_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_higher_order_degrees_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_higher_order_degrees_on(self.0) } + } + fn copy_higher_order_degrees_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_higher_order_degrees_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_copy_higher_order_degrees_off(self.0) } + } + fn copy_all_on(&mut self, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_all_on( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_copy_all_on(self.0, ctype) } + } + fn copy_all_off(&mut self, ctype: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_all_off( + sself: *mut core::ffi::c_void, + ctype: core::ffi::c_int, + ); + } + unsafe { vtk_data_set_attributes_copy_all_off(self.0, ctype) } + } + fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_pass_data( + sself: *mut core::ffi::c_void, + fd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_pass_data(self.0, fd) } + } + fn copy_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_allocate( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ); + } + unsafe { vtk_data_set_attributes_copy_allocate(self.0, pd, sze, ext) } + } + fn setup_for_copy(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_setup_for_copy( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_attributes_setup_for_copy(self.0, pd) } + } + fn copy_data( + &mut self, + fromPd: *mut core::ffi::c_void, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_data( + sself: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, + ); + } + unsafe { vtk_data_set_attributes_copy_data(self.0, fromPd, fromId, toId) } + } + fn copy_tuple( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tuple( + sself: *mut core::ffi::c_void, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromId: core::ffi::c_longlong, + toId: core::ffi::c_longlong, + ); + } + unsafe { + vtk_data_set_attributes_copy_tuple(self.0, fromData, toData, fromId, toId) + } + } + fn copy_tuples( + &mut self, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_copy_tuples( + sself: *mut core::ffi::c_void, + fromData: *mut core::ffi::c_void, + toData: *mut core::ffi::c_void, + fromIds: *mut core::ffi::c_void, + toIds: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_data_set_attributes_copy_tuples(self.0, fromData, toData, fromIds, toIds) + } + } + fn interpolate_allocate( + &mut self, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_allocate( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + sze: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ); + } + unsafe { vtk_data_set_attributes_interpolate_allocate(self.0, pd, sze, ext) } + } + fn interpolate_edge( + &mut self, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + t: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_edge( + sself: *mut core::ffi::c_void, + fromPd: *mut core::ffi::c_void, + toId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + t: core::ffi::c_double, + ); + } + unsafe { + vtk_data_set_attributes_interpolate_edge(self.0, fromPd, toId, p1, p2, t) + } + } + fn interpolate_time( + &mut self, + from1: *mut core::ffi::c_void, + from2: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + t: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_data_set_attributes_interpolate_time( + sself: *mut core::ffi::c_void, + from1: *mut core::ffi::c_void, + from2: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + t: core::ffi::c_double, + ); + } + unsafe { vtk_data_set_attributes_interpolate_time(self.0, from1, from2, id, t) } + } +} +impl VtkDataSetCellIterator for vtkDataSetCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_cell_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_cell_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_cell_iterator_new_instance(self.0) } + } + fn is_done_with_traversal(&mut self) -> bool { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_data_set_cell_iterator_is_done_with_traversal(self.0) } + } + fn get_cell_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_data_set_cell_iterator_get_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_data_set_cell_iterator_get_cell_id(self.0) } + } +} +impl VtkDataSetCollection for vtkDataSetCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_next_item(self.0) } + } + fn get_next_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_next_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_next_data_set(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_item(self.0, i) } + } + fn get_data_set(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_collection_get_data_set( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_collection_get_data_set(self.0, i) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_data_set_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_data_set_collection_get_number_of_items(self.0) } + } +} +impl VtkDirectedAcyclicGraph for vtkDirectedAcyclicGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_new_instance(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_acyclic_graph_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_acyclic_graph_get_data(self.0, info) } + } +} +impl VtkDirectedGraph for vtkDirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_new_instance(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_get_data(self.0, info) } + } + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_directed_graph_is_structure_valid( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_directed_graph_is_structure_valid(self.0, g) } + } +} +impl VtkEdgeListIterator for vtkEdgeListIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_new_instance(self.0) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_get_graph(self.0) } + } + fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_edge_list_iterator_set_graph( + sself: *mut core::ffi::c_void, + graph: *mut core::ffi::c_void, + ); + } + unsafe { vtk_edge_list_iterator_set_graph(self.0, graph) } + } + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_list_iterator_next_graph_edge( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_list_iterator_next_graph_edge(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_edge_list_iterator_has_next(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_edge_list_iterator_has_next(self.0) } + } +} +impl VtkEdgeTable for vtkEdgeTable { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_table_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_table_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_table_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_table_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_edge_table_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_edge_table_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_edge_table_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_edge_table_initialize(self.0) } + } + fn init_edge_insertion( + &mut self, + numPoints: core::ffi::c_longlong, + storeAttributes: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_edge_table_init_edge_insertion( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + storeAttributes: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_edge_table_init_edge_insertion(self.0, numPoints, storeAttributes) } + } + fn insert_edge( + &mut self, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_edge_table_insert_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_edge_table_insert_edge(self.0, p1, p2) } + } + fn is_edge( + &mut self, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_edge_table_is_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_edge_table_is_edge(self.0, p1, p2) } + } + fn init_point_insertion( + &mut self, + newPts: *mut core::ffi::c_void, + estSize: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_edge_table_init_point_insertion( + sself: *mut core::ffi::c_void, + newPts: *mut core::ffi::c_void, + estSize: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_edge_table_init_point_insertion(self.0, newPts, estSize) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_edge_table_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_edge_table_get_number_of_edges(self.0) } + } + fn init_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_edge_table_init_traversal(sself: *mut core::ffi::c_void); + } + unsafe { vtk_edge_table_init_traversal(self.0) } + } + fn get_next_edge( + &mut self, + p1: &mut core::ffi::c_longlong, + p2: &mut core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_edge_table_get_next_edge( + sself: *mut core::ffi::c_void, + p1: &mut core::ffi::c_longlong, + p2: &mut core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_edge_table_get_next_edge(self.0, p1, p2) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_edge_table_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_edge_table_reset(self.0) } + } +} +impl VtkEmptyCell for vtkEmptyCell { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_empty_cell_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_empty_cell_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_empty_cell_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_empty_cell_contour( + self.0, + value, + cellScalars, + locator, + verts1, + lines, + verts2, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_empty_cell_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_empty_cell_clip( + self.0, + value, + cellScalars, + locator, + pts, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_empty_cell_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_empty_cell_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkExplicitStructuredGrid for vtkExplicitStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_data_object_type(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_explicit_structured_grid_initialize(self.0) } + } + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_cell(self.0, cellId) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_cell_type(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_get_point_cells(self.0, ptId, cellIds) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_copy_structure(self.0, ds) } + } + fn get_data_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_data_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_data_dimension(self.0) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_explicit_structured_grid_set_dimensions(self.0, i, j, k) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_explicit_structured_grid_get_extent_type(self.0) } + } + fn set_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_extent( + sself: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { + vtk_explicit_structured_grid_set_extent(self.0, x0, x1, y0, y1, z0, z1) + } + } + fn set_cells(&mut self, cells: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_cells( + sself: *mut core::ffi::c_void, + cells: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_set_cells(self.0, cells) } + } + fn get_cells(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_cells( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_cells(self.0) } + } + fn build_links(&mut self) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_build_links(sself: *mut core::ffi::c_void); + } + unsafe { vtk_explicit_structured_grid_build_links(self.0) } + } + fn get_links(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_links( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_links(self.0) } + } + fn compute_cell_structured_coords( + &mut self, + cellId: core::ffi::c_longlong, + i: &mut core::ffi::c_int, + j: &mut core::ffi::c_int, + k: &mut core::ffi::c_int, + adjustForExtent: bool, + ) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_compute_cell_structured_coords( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + i: &mut core::ffi::c_int, + j: &mut core::ffi::c_int, + k: &mut core::ffi::c_int, + adjustForExtent: bool, + ); + } + unsafe { + vtk_explicit_structured_grid_compute_cell_structured_coords( + self.0, + cellId, + i, + j, + k, + adjustForExtent, + ) + } + } + fn compute_cell_id( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_explicit_structured_grid_compute_cell_id( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + adjustForExtent: bool, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_explicit_structured_grid_compute_cell_id( + self.0, + i, + j, + k, + adjustForExtent, + ) + } + } + fn compute_faces_connectivity_flags_array(&mut self) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_compute_faces_connectivity_flags_array( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_explicit_structured_grid_compute_faces_connectivity_flags_array(self.0) + } + } + fn set_faces_connectivity_flags_array_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { + vtk_explicit_structured_grid_set_faces_connectivity_flags_array_name( + self.0, + c__arg.as_ptr(), + ) + } + } + fn blank_cell(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_blank_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_explicit_structured_grid_blank_cell(self.0, cellId) } + } + fn un_blank_cell(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_un_blank_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_explicit_structured_grid_un_blank_cell(self.0, cellId) } + } + fn has_any_blank_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_explicit_structured_grid_has_any_blank_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_explicit_structured_grid_has_any_blank_cells(self.0) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_explicit_structured_grid_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_explicit_structured_grid_is_cell_visible(self.0, cellId) } + } + fn is_cell_ghost(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_explicit_structured_grid_is_cell_ghost( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_explicit_structured_grid_is_cell_ghost(self.0, cellId) } + } + fn has_any_ghost_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_explicit_structured_grid_has_any_ghost_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_explicit_structured_grid_has_any_ghost_cells(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_get_data(self.0, info) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_explicit_structured_grid_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_explicit_structured_grid_get_actual_memory_size(self.0) } + } + fn check_and_reorder_faces(&mut self) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_check_and_reorder_faces( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_check_and_reorder_faces(self.0) } + } +} +impl VtkExtractStructuredGridHelper for vtkExtractStructuredGridHelper { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extract_structured_grid_helper_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extract_structured_grid_helper_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extract_structured_grid_helper_new_instance(self.0) } + } + fn is_valid(&mut self) -> bool { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_is_valid( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_extract_structured_grid_helper_is_valid(self.0) } + } + fn get_size(&mut self, dim: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_size( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_extract_structured_grid_helper_get_size(self.0, dim) } + } + fn get_mapped_index( + &mut self, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_mapped_index( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extract_structured_grid_helper_get_mapped_index(self.0, dim, outIdx) + } + } + fn get_mapped_index_from_extent_value( + &mut self, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extract_structured_grid_helper_get_mapped_index_from_extent_value( + self.0, + dim, + outExtVal, + ) + } + } + fn get_mapped_extent_value( + &mut self, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_mapped_extent_value( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + outExtVal: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extract_structured_grid_helper_get_mapped_extent_value( + self.0, + dim, + outExtVal, + ) + } + } + fn get_mapped_extent_value_from_index( + &mut self, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index( + sself: *mut core::ffi::c_void, + dim: core::ffi::c_int, + outIdx: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_extract_structured_grid_helper_get_mapped_extent_value_from_index( + self.0, + dim, + outIdx, + ) + } + } +} +impl VtkFieldData for vtkFieldData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_new_instance(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_field_data_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_field_data_initialize(self.0) } + } + fn allocate( + &mut self, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_allocate( + sself: *mut core::ffi::c_void, + sz: core::ffi::c_longlong, + ext: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_allocate(self.0, sz, ext) } + } + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_field_data_copy_structure( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_copy_structure(self.0, p0) } + } + fn allocate_arrays(&mut self, num: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_field_data_allocate_arrays( + sself: *mut core::ffi::c_void, + num: core::ffi::c_int, + ); + } + unsafe { vtk_field_data_allocate_arrays(self.0, num) } + } + fn get_number_of_arrays(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_get_number_of_arrays( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_get_number_of_arrays(self.0) } + } + fn add_array(&mut self, array: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_add_array( + sself: *mut core::ffi::c_void, + array: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_add_array(self.0, array) } + } + fn null_data(&mut self, id: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_field_data_null_data( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_field_data_null_data(self.0, id) } + } + fn remove_array(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_field_data_remove_array( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_field_data_remove_array(self.0, c_name.as_ptr()) } + } + fn get_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_get_array( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_get_array(self.0, i) } + } + fn get_abstract_array(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_field_data_get_abstract_array( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_field_data_get_abstract_array(self.0, i) } + } + fn has_array(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_field_data_has_array( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_has_array(self.0, c_name.as_ptr()) } + } + fn get_array_name(&mut self, i: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_field_data_get_array_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_field_data_get_array_name(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn pass_data(&mut self, fd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_field_data_pass_data( + sself: *mut core::ffi::c_void, + fd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_pass_data(self.0, fd) } + } + fn copy_field_on(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_field_data_copy_field_on( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_field_data_copy_field_on(self.0, c_name.as_ptr()) } + } + fn copy_field_off(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_field_data_copy_field_off( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_field_data_copy_field_off(self.0, c_name.as_ptr()) } + } + fn copy_all_on(&mut self, unused: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_field_data_copy_all_on( + sself: *mut core::ffi::c_void, + unused: core::ffi::c_int, + ); + } + unsafe { vtk_field_data_copy_all_on(self.0, unused) } + } + fn copy_all_off(&mut self, unused: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_field_data_copy_all_off( + sself: *mut core::ffi::c_void, + unused: core::ffi::c_int, + ); + } + unsafe { vtk_field_data_copy_all_off(self.0, unused) } + } + fn deep_copy(&mut self, da: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_field_data_deep_copy( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_deep_copy(self.0, da) } + } + fn shallow_copy(&mut self, da: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_field_data_shallow_copy( + sself: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_shallow_copy(self.0, da) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_field_data_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_field_data_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_field_data_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_field_data_reset(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_field_data_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_field_data_get_actual_memory_size(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_field_data_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_field_data_get_m_time(self.0) } + } + fn get_field( + &mut self, + ptId: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_field_data_get_field( + sself: *mut core::ffi::c_void, + ptId: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_get_field(self.0, ptId, f) } + } + fn get_array_containing_component( + &mut self, + i: core::ffi::c_int, + arrayComp: &mut core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_get_array_containing_component( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + arrayComp: &mut core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_get_array_containing_component(self.0, i, arrayComp) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_field_data_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_field_data_get_number_of_components(self.0) } + } + fn get_number_of_tuples(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_field_data_get_number_of_tuples( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_field_data_get_number_of_tuples(self.0) } + } + fn set_number_of_tuples(&mut self, number: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_field_data_set_number_of_tuples( + sself: *mut core::ffi::c_void, + number: core::ffi::c_longlong, + ); + } + unsafe { vtk_field_data_set_number_of_tuples(self.0, number) } + } + fn set_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_field_data_set_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_set_tuple(self.0, i, j, source) } + } + fn insert_tuple( + &mut self, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_field_data_insert_tuple( + sself: *mut core::ffi::c_void, + i: core::ffi::c_longlong, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_field_data_insert_tuple(self.0, i, j, source) } + } + fn insert_next_tuple( + &mut self, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_field_data_insert_next_tuple( + sself: *mut core::ffi::c_void, + j: core::ffi::c_longlong, + source: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_field_data_insert_next_tuple(self.0, j, source) } + } +} +impl VtkGenericAttributeCollection for vtkGenericAttributeCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_attribute_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_attribute_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_attribute_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_attribute_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_attribute_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_attribute_collection_new_instance(self.0) } + } + fn get_number_of_attributes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_number_of_attributes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_number_of_attributes(self.0) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_number_of_components(self.0) } + } + fn get_number_of_point_centered_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_number_of_point_centered_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_attribute_collection_get_number_of_point_centered_components( + self.0, + ) + } + } + fn get_max_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_max_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_max_number_of_components(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_generic_attribute_collection_get_actual_memory_size(self.0) } + } + fn is_empty(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_is_empty( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_is_empty(self.0) } + } + fn get_attribute(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_attribute( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_attribute_collection_get_attribute(self.0, i) } + } + fn find_attribute(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_generic_attribute_collection_find_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_attribute_collection_find_attribute(self.0, c_name.as_ptr()) + } + } + fn get_attribute_index(&mut self, i: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_attribute_index( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_attribute_index(self.0, i) } + } + fn insert_next_attribute(&mut self, a: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_insert_next_attribute( + sself: *mut core::ffi::c_void, + a: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_attribute_collection_insert_next_attribute(self.0, a) } + } + fn insert_attribute( + &mut self, + i: core::ffi::c_int, + a: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_insert_attribute( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + a: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_attribute_collection_insert_attribute(self.0, i, a) } + } + fn remove_attribute(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_remove_attribute( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_generic_attribute_collection_remove_attribute(self.0, i) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_attribute_collection_reset(self.0) } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_attribute_collection_deep_copy(self.0, other) } + } + fn shallow_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_shallow_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_attribute_collection_shallow_copy(self.0, other) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_generic_attribute_collection_get_m_time(self.0) } + } + fn get_active_attribute(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_active_attribute( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_active_attribute(self.0) } + } + fn get_active_component(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_active_component( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_attribute_collection_get_active_component(self.0) } + } + fn set_active_attribute( + &mut self, + attribute: core::ffi::c_int, + component: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_set_active_attribute( + sself: *mut core::ffi::c_void, + attribute: core::ffi::c_int, + component: core::ffi::c_int, + ); + } + unsafe { + vtk_generic_attribute_collection_set_active_attribute( + self.0, + attribute, + component, + ) + } + } + fn get_number_of_attributes_to_interpolate(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_attribute_collection_get_number_of_attributes_to_interpolate( + self.0, + ) + } + } + fn set_attributes_to_interpolate_to_all(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_generic_attribute_collection_set_attributes_to_interpolate_to_all(self.0) + } + } +} +impl VtkGenericCell for vtkGenericCell { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_new_instance(self.0) } + } + fn set_points(&mut self, points: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_points( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_points(self.0, points) } + } + fn set_point_ids(&mut self, pointIds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_point_ids( + sself: *mut core::ffi::c_void, + pointIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_point_ids(self.0, pointIds) } + } + fn shallow_copy(&mut self, c: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_cell_shallow_copy( + sself: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_shallow_copy(self.0, c) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_generic_cell_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_generic_cell_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_generic_cell_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_generic_cell_clip( + self.0, + value, + cellScalars, + locator, + connectivity, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_cell_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_cell_triangulate(self.0, index, ptIds, pts) } + } + fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + ); + } + unsafe { vtk_generic_cell_set_cell_type(self.0, cellType) } + } + fn set_cell_type_to_empty_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_empty_cell( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_empty_cell(self.0) } + } + fn set_cell_type_to_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_vertex(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_vertex(self.0) } + } + fn set_cell_type_to_poly_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_poly_vertex( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_poly_vertex(self.0) } + } + fn set_cell_type_to_line(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_line(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_line(self.0) } + } + fn set_cell_type_to_poly_line(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_poly_line( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_poly_line(self.0) } + } + fn set_cell_type_to_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_triangle(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_triangle(self.0) } + } + fn set_cell_type_to_triangle_strip(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_triangle_strip( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_triangle_strip(self.0) } + } + fn set_cell_type_to_polygon(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_polygon(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_polygon(self.0) } + } + fn set_cell_type_to_pixel(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_pixel(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_pixel(self.0) } + } + fn set_cell_type_to_quad(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quad(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_quad(self.0) } + } + fn set_cell_type_to_tetra(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_tetra(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_tetra(self.0) } + } + fn set_cell_type_to_voxel(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_voxel(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_voxel(self.0) } + } + fn set_cell_type_to_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_hexahedron(self.0) } + } + fn set_cell_type_to_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_wedge(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_wedge(self.0) } + } + fn set_cell_type_to_pyramid(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_pyramid(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_cell_set_cell_type_to_pyramid(self.0) } + } + fn set_cell_type_to_pentagonal_prism(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_pentagonal_prism( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_pentagonal_prism(self.0) } + } + fn set_cell_type_to_hexagonal_prism(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_hexagonal_prism( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_hexagonal_prism(self.0) } + } + fn set_cell_type_to_polyhedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_polyhedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_polyhedron(self.0) } + } + fn set_cell_type_to_convex_point_set(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_convex_point_set( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_convex_point_set(self.0) } + } + fn set_cell_type_to_quadratic_edge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_edge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_edge(self.0) } + } + fn set_cell_type_to_cubic_line(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_cubic_line( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_cubic_line(self.0) } + } + fn set_cell_type_to_quadratic_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_triangle(self.0) } + } + fn set_cell_type_to_bi_quadratic_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bi_quadratic_triangle(self.0) } + } + fn set_cell_type_to_quadratic_quad(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_quad( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_quad(self.0) } + } + fn set_cell_type_to_quadratic_polygon(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_polygon( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_polygon(self.0) } + } + fn set_cell_type_to_quadratic_tetra(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_tetra( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_tetra(self.0) } + } + fn set_cell_type_to_quadratic_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_hexahedron(self.0) } + } + fn set_cell_type_to_quadratic_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_wedge(self.0) } + } + fn set_cell_type_to_quadratic_pyramid(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_pyramid( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_pyramid(self.0) } + } + fn set_cell_type_to_quadratic_linear_quad(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_linear_quad( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_linear_quad(self.0) } + } + fn set_cell_type_to_bi_quadratic_quad(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bi_quadratic_quad( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bi_quadratic_quad(self.0) } + } + fn set_cell_type_to_quadratic_linear_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_quadratic_linear_wedge(self.0) } + } + fn set_cell_type_to_bi_quadratic_quadratic_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_wedge(self.0) } + } + fn set_cell_type_to_tri_quadratic_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_tri_quadratic_hexahedron(self.0) } + } + fn set_cell_type_to_tri_quadratic_pyramid(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_tri_quadratic_pyramid(self.0) } + } + fn set_cell_type_to_bi_quadratic_quadratic_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_generic_cell_set_cell_type_to_bi_quadratic_quadratic_hexahedron(self.0) + } + } + fn set_cell_type_to_lagrange_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_triangle(self.0) } + } + fn set_cell_type_to_lagrange_tetra(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_tetra( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_tetra(self.0) } + } + fn set_cell_type_to_lagrange_curve(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_curve( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_curve(self.0) } + } + fn set_cell_type_to_lagrange_quadrilateral(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_quadrilateral(self.0) } + } + fn set_cell_type_to_lagrange_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_hexahedron(self.0) } + } + fn set_cell_type_to_lagrange_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_lagrange_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_lagrange_wedge(self.0) } + } + fn set_cell_type_to_bezier_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_triangle(self.0) } + } + fn set_cell_type_to_bezier_tetra(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_tetra( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_tetra(self.0) } + } + fn set_cell_type_to_bezier_curve(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_curve( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_curve(self.0) } + } + fn set_cell_type_to_bezier_quadrilateral(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_quadrilateral( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_quadrilateral(self.0) } + } + fn set_cell_type_to_bezier_hexahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_hexahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_hexahedron(self.0) } + } + fn set_cell_type_to_bezier_wedge(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_cell_set_cell_type_to_bezier_wedge( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_cell_set_cell_type_to_bezier_wedge(self.0) } + } + fn instantiate_cell( + &mut self, + cellType: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_instantiate_cell( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_instantiate_cell(self.0, cellType) } + } + fn get_representative_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_cell_get_representative_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_cell_get_representative_cell(self.0) } + } +} +impl VtkGenericEdgeTable for vtkGenericEdgeTable { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_edge_table_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_edge_table_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_edge_table_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_edge_table_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_edge_table_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_edge_table_new_instance(self.0) } + } + fn insert_edge( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ref_: core::ffi::c_int, + ptId: &mut core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_insert_edge( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ref_: core::ffi::c_int, + ptId: &mut core::ffi::c_longlong, + ); + } + unsafe { vtk_generic_edge_table_insert_edge(self.0, e1, e2, cellId, ref_, ptId) } + } + fn remove_edge( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_remove_edge( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_remove_edge(self.0, e1, e2) } + } + fn check_edge( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ptId: &mut core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_check_edge( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ptId: &mut core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_check_edge(self.0, e1, e2, ptId) } + } + fn increment_edge_reference_count( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_increment_edge_reference_count( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { + vtk_generic_edge_table_increment_edge_reference_count(self.0, e1, e2, cellId) + } + } + fn check_edge_reference_count( + &mut self, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_check_edge_reference_count( + sself: *mut core::ffi::c_void, + e1: core::ffi::c_longlong, + e2: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_check_edge_reference_count(self.0, e1, e2) } + } + fn initialize(&mut self, start: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_initialize( + sself: *mut core::ffi::c_void, + start: core::ffi::c_longlong, + ); + } + unsafe { vtk_generic_edge_table_initialize(self.0, start) } + } + fn get_number_of_components(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_get_number_of_components( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_get_number_of_components(self.0) } + } + fn set_number_of_components(&mut self, count: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_set_number_of_components( + sself: *mut core::ffi::c_void, + count: core::ffi::c_int, + ); + } + unsafe { vtk_generic_edge_table_set_number_of_components(self.0, count) } + } + fn check_point(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_edge_table_check_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_edge_table_check_point(self.0, ptId) } + } + fn remove_point(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_remove_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_generic_edge_table_remove_point(self.0, ptId) } + } + fn increment_point_reference_count(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_increment_point_reference_count( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_generic_edge_table_increment_point_reference_count(self.0, ptId) } + } + fn dump_table(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_dump_table(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_edge_table_dump_table(self.0) } + } + fn load_factor(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_edge_table_load_factor(sself: *mut core::ffi::c_void); + } + unsafe { vtk_generic_edge_table_load_factor(self.0) } + } +} +impl VtkGenericInterpolatedVelocityField for vtkGenericInterpolatedVelocityField { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_new(self.0) } + } + fn add_data_set(&mut self, dataset: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_add_data_set( + sself: *mut core::ffi::c_void, + dataset: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_add_data_set(self.0, dataset) } + } + fn clear_last_cell(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_clear_last_cell( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_clear_last_cell(self.0) } + } + fn get_last_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_last_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_get_last_cell(self.0) } + } + fn get_caching(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_caching( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_interpolated_velocity_field_get_caching(self.0) } + } + fn set_caching(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_set_caching( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_set_caching(self.0, _arg) } + } + fn caching_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_caching_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_caching_on(self.0) } + } + fn caching_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_caching_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_caching_off(self.0) } + } + fn get_cache_hit(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_cache_hit( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_interpolated_velocity_field_get_cache_hit(self.0) } + } + fn get_cache_miss(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_cache_miss( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_generic_interpolated_velocity_field_get_cache_miss(self.0) } + } + fn select_vectors(&mut self, fieldName: &str) -> () { + let c_fieldName = std::ffi::CString::new(fieldName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_select_vectors( + sself: *mut core::ffi::c_void, + fieldName: *const core::ffi::c_char, + ); + } + unsafe { + vtk_generic_interpolated_velocity_field_select_vectors( + self.0, + c_fieldName.as_ptr(), + ) + } + } + fn get_last_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_get_last_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_generic_interpolated_velocity_field_get_last_data_set(self.0) } + } + fn copy_parameters(&mut self, from: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_generic_interpolated_velocity_field_copy_parameters( + sself: *mut core::ffi::c_void, + from: *mut core::ffi::c_void, + ); + } + unsafe { vtk_generic_interpolated_velocity_field_copy_parameters(self.0, from) } + } +} +impl VtkGeometricErrorMetric for vtkGeometricErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_geometric_error_metric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_geometric_error_metric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_geometric_error_metric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_geometric_error_metric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_geometric_error_metric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_geometric_error_metric_new_instance(self.0) } + } + fn get_absolute_geometric_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_geometric_error_metric_get_absolute_geometric_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_geometric_error_metric_get_absolute_geometric_tolerance(self.0) } + } + fn set_absolute_geometric_tolerance(&mut self, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_geometric_error_metric_set_absolute_geometric_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_geometric_error_metric_set_absolute_geometric_tolerance(self.0, value) + } + } + fn set_relative_geometric_tolerance( + &mut self, + value: core::ffi::c_double, + ds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_geometric_error_metric_set_relative_geometric_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ds: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_geometric_error_metric_set_relative_geometric_tolerance( + self.0, + value, + ds, + ) + } + } + fn get_relative(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_geometric_error_metric_get_relative( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_geometric_error_metric_get_relative(self.0) } + } +} +impl VtkGraphEdge for vtkGraphEdge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_edge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_edge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_edge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_edge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_edge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_edge_new_instance(self.0) } + } + fn set_source(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_graph_edge_set_source( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_graph_edge_set_source(self.0, _arg) } + } + fn get_source(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_graph_edge_get_source( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_graph_edge_get_source(self.0) } + } + fn set_target(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_graph_edge_set_target( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_graph_edge_set_target(self.0, _arg) } + } + fn get_target(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_graph_edge_get_target( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_graph_edge_get_target(self.0) } + } + fn set_id(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_graph_edge_set_id( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_graph_edge_set_id(self.0, _arg) } + } + fn get_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_graph_edge_get_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_graph_edge_get_id(self.0) } + } +} +impl VtkGraphInternals for vtkGraphInternals { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_internals_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_internals_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_internals_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_internals_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_internals_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_internals_new_instance(self.0) } + } +} +impl VtkHexagonalPrism for vtkHexagonalPrism { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexagonal_prism_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexagonal_prism_get_face(self.0, faceId) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexagonal_prism_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexagonal_prism_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkHexahedron for vtkHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hexahedron_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hexahedron_get_face(self.0, faceId) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hexahedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hexahedron_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkHierarchicalBoxDataIterator for vtkHierarchicalBoxDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_iterator_new_instance(self.0) } + } +} +impl VtkHierarchicalBoxDataSet for vtkHierarchicalBoxDataSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_new_instance(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_new_iterator(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_get_data(self.0, info) } + } +} +impl VtkHyperTreeGrid for vtkHyperTreeGrid { + fn levels(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_levels( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_levels(self.0) } + } + fn dimension(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_dimension( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_dimension(self.0) } + } + fn orientation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_orientation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_orientation(self.0) } + } + fn sizes(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_sizes( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_sizes(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_new_instance(self.0) } + } + fn set_mode_squeeze(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_mode_squeeze( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_hyper_tree_grid_set_mode_squeeze(self.0, c__arg.as_ptr()) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_squeeze(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hyper_tree_grid_get_data_object_type(self.0) } + } + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_copy_structure( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_copy_structure(self.0, p0) } + } + fn copy_empty_structure(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_copy_empty_structure( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_copy_empty_structure(self.0, p0) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_uint, + j: core::ffi::c_uint, + k: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_uint, + j: core::ffi::c_uint, + k: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_set_dimensions(self.0, i, j, k) } + } + fn set_extent( + &mut self, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_extent( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ); + } + unsafe { vtk_hyper_tree_grid_set_extent(self.0, x1, x2, y1, y2, z1, z2) } + } + fn get_dimension(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_dimension(self.0) } + } + fn get_1_d_axis(&mut self, axis: &mut core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_1_d_axis( + sself: *mut core::ffi::c_void, + axis: &mut core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_get_1_d_axis(self.0, axis) } + } + fn get_2_d_axes( + &mut self, + axis1: &mut core::ffi::c_uint, + axis2: &mut core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_2_d_axes( + sself: *mut core::ffi::c_void, + axis1: &mut core::ffi::c_uint, + axis2: &mut core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_get_2_d_axes(self.0, axis1, axis2) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_number_of_children(self.0) } + } + fn set_transposed_root_indexing(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_transposed_root_indexing( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_set_transposed_root_indexing(self.0, _arg) } + } + fn get_transposed_root_indexing(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_transposed_root_indexing( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_get_transposed_root_indexing(self.0) } + } + fn set_indexing_mode_to_kji(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_indexing_mode_to_kji( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_indexing_mode_to_kji(self.0) } + } + fn set_indexing_mode_to_ijk(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_indexing_mode_to_ijk( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_indexing_mode_to_ijk(self.0) } + } + fn get_orientation(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_orientation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_orientation(self.0) } + } + fn get_freeze_state(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_freeze_state( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_get_freeze_state(self.0) } + } + fn set_branch_factor(&mut self, p0: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_branch_factor( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_set_branch_factor(self.0, p0) } + } + fn get_branch_factor(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_branch_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_branch_factor(self.0) } + } + fn get_max_number_of_trees(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_max_number_of_trees( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_get_max_number_of_trees(self.0) } + } + fn get_number_of_vertices(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_vertices( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_get_number_of_vertices(self.0) } + } + fn get_number_of_non_empty_trees(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_non_empty_trees( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_get_number_of_non_empty_trees(self.0) } + } + fn get_number_of_leaves(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_leaves( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_get_number_of_leaves(self.0) } + } + fn get_number_of_levels(&mut self, p0: core::ffi::c_longlong) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_levels( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_number_of_levels(self.0, p0) } + } + fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_x_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_x_coordinates(self.0, p0) } + } + fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_x_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_x_coordinates(self.0) } + } + fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_y_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_y_coordinates(self.0, p0) } + } + fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_y_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_y_coordinates(self.0) } + } + fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_z_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_z_coordinates(self.0, p0) } + } + fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_z_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_z_coordinates(self.0) } + } + fn set_fixed_coordinates( + &mut self, + axis: core::ffi::c_uint, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_fixed_coordinates( + sself: *mut core::ffi::c_void, + axis: core::ffi::c_uint, + value: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_set_fixed_coordinates(self.0, axis, value) } + } + fn set_mask(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_mask( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_mask(self.0, p0) } + } + fn get_mask(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_mask( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_mask(self.0) } + } + fn has_mask(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_has_mask(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_hyper_tree_grid_has_mask(self.0) } + } + fn set_has_interface(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_has_interface( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_set_has_interface(self.0, _arg) } + } + fn get_has_interface(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_has_interface( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_get_has_interface(self.0) } + } + fn has_interface_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_has_interface_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_has_interface_on(self.0) } + } + fn has_interface_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_has_interface_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_has_interface_off(self.0) } + } + fn set_interface_normals_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_interface_normals_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { + vtk_hyper_tree_grid_set_interface_normals_name(self.0, c__arg.as_ptr()) + } + } + fn set_interface_intercepts_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_interface_intercepts_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { + vtk_hyper_tree_grid_set_interface_intercepts_name(self.0, c__arg.as_ptr()) + } + } + fn set_depth_limiter(&mut self, _arg: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_depth_limiter( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_set_depth_limiter(self.0, _arg) } + } + fn get_depth_limiter(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_depth_limiter( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_depth_limiter(self.0) } + } + fn initialize_oriented_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_oriented_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_oriented_cursor(self.0, cursor, index, create) + } + } + fn new_oriented_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_oriented_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_new_oriented_cursor(self.0, index, create) } + } + fn initialize_oriented_geometry_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_oriented_geometry_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_oriented_geometry_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_oriented_geometry_cursor(self.0, index, create) + } + } + fn initialize_non_oriented_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_new_non_oriented_cursor(self.0, index, create) } + } + fn initialize_non_oriented_geometry_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_geometry_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_geometry_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_geometry_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_geometry_cursor(self.0, index, create) + } + } + fn find_dichotomic_x(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_find_dichotomic_x( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_find_dichotomic_x(self.0, value) } + } + fn find_dichotomic_y(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_find_dichotomic_y( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_find_dichotomic_y(self.0, value) } + } + fn find_dichotomic_z(&mut self, value: core::ffi::c_double) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_find_dichotomic_z( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_find_dichotomic_z(self.0, value) } + } + fn initialize_non_oriented_von_neumann_super_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_von_neumann_super_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor( + self.0, + index, + create, + ) + } + } + fn initialize_non_oriented_von_neumann_super_cursor_light( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor_light( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_von_neumann_super_cursor_light( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_von_neumann_super_cursor_light( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor_light( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_von_neumann_super_cursor_light( + self.0, + index, + create, + ) + } + } + fn initialize_non_oriented_moore_super_cursor( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_moore_super_cursor( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor( + self.0, + index, + create, + ) + } + } + fn initialize_non_oriented_moore_super_cursor_light( + &mut self, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor_light( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_initialize_non_oriented_moore_super_cursor_light( + self.0, + cursor, + index, + create, + ) + } + } + fn new_non_oriented_moore_super_cursor_light( + &mut self, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor_light( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_new_non_oriented_moore_super_cursor_light( + self.0, + index, + create, + ) + } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_initialize(self.0) } + } + fn get_tree( + &mut self, + p0: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_tree( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + create: bool, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_tree(self.0, p0, create) } + } + fn set_tree(&mut self, p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_set_tree( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_set_tree(self.0, p0, p1) } + } + fn shallow_copy(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_shallow_copy( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_shallow_copy(self.0, p0) } + } + fn deep_copy(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_deep_copy( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_deep_copy(self.0, p0) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_hyper_tree_grid_get_extent_type(self.0) } + } + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_actual_memory_size_bytes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_hyper_tree_grid_get_actual_memory_size_bytes(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_hyper_tree_grid_get_actual_memory_size(self.0) } + } + fn recursively_initialize_pure_mask( + &mut self, + cursor: *mut core::ffi::c_void, + normale: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_recursively_initialize_pure_mask( + sself: *mut core::ffi::c_void, + cursor: *mut core::ffi::c_void, + normale: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_hyper_tree_grid_recursively_initialize_pure_mask(self.0, cursor, normale) + } + } + fn get_pure_mask(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_pure_mask( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_pure_mask(self.0) } + } + fn get_child_mask(&mut self, p0: core::ffi::c_uint) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_child_mask( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_get_child_mask(self.0, p0) } + } + fn get_index_from_level_zero_coordinates( + &mut self, + p0: &mut core::ffi::c_longlong, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_index_from_level_zero_coordinates( + sself: *mut core::ffi::c_void, + p0: &mut core::ffi::c_longlong, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ); + } + unsafe { + vtk_hyper_tree_grid_get_index_from_level_zero_coordinates( + self.0, + p0, + p1, + p2, + p3, + ) + } + } + fn get_shifted_level_zero_index( + &mut self, + p0: core::ffi::c_longlong, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_shifted_level_zero_index( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + p1: core::ffi::c_uint, + p2: core::ffi::c_uint, + p3: core::ffi::c_uint, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_hyper_tree_grid_get_shifted_level_zero_index(self.0, p0, p1, p2, p3) + } + } + fn get_level_zero_coordinates_from_index( + &mut self, + p0: core::ffi::c_longlong, + p1: &mut core::ffi::c_uint, + p2: &mut core::ffi::c_uint, + p3: &mut core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_level_zero_coordinates_from_index( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + p1: &mut core::ffi::c_uint, + p2: &mut core::ffi::c_uint, + p3: &mut core::ffi::c_uint, + ); + } + unsafe { + vtk_hyper_tree_grid_get_level_zero_coordinates_from_index( + self.0, + p0, + p1, + p2, + p3, + ) + } + } + fn get_global_node_index_max(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_global_node_index_max( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_get_global_node_index_max(self.0) } + } + fn initialize_local_index_node(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_initialize_local_index_node( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_initialize_local_index_node(self.0) } + } + fn has_any_ghost_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_has_any_ghost_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_has_any_ghost_cells(self.0) } + } + fn get_ghost_cells(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_ghost_cells( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_ghost_cells(self.0) } + } + fn get_tree_ghost_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_tree_ghost_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_tree_ghost_array(self.0) } + } + fn allocate_tree_ghost_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_allocate_tree_ghost_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_allocate_tree_ghost_array(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_data(self.0, info) } + } + fn get_cell_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_cell_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_cell_data(self.0) } + } + fn get_attributes_as_field_data( + &mut self, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_attributes_as_field_data( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_get_attributes_as_field_data(self.0, type_) } + } + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_get_number_of_elements( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_get_number_of_elements(self.0, type_) } + } +} +impl VtkHyperTreeGridNonOrientedCursor for vtkHyperTreeGridNonOrientedCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_new(self.0) } + } + fn clone(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_clone( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_clone(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn get_grid(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_grid( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_grid(self.0) } + } + fn has_tree(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_has_tree( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_has_tree(self.0) } + } + fn get_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_tree(self.0) } + } + fn get_vertex_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_vertex_id(self.0) } + } + fn get_global_node_index(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_global_node_index(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_dimension(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_number_of_children(self.0) } + } + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_start(self.0, index) + } + } + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_cursor_set_global_index_from_local( + self.0, + index, + ) + } + } + fn set_mask(&mut self, state: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_set_mask( + sself: *mut core::ffi::c_void, + state: bool, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_set_mask(self.0, state) } + } + fn is_masked(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_is_masked( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_is_masked(self.0) } + } + fn is_leaf(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_is_leaf( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_is_leaf(self.0) } + } + fn subdivide_leaf(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_subdivide_leaf(self.0) } + } + fn is_root(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_is_root( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_is_root(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_get_level(self.0) } + } + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_to_child( + sself: *mut core::ffi::c_void, + ichild: core::ffi::c_uchar, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_to_child(self.0, ichild) } + } + fn to_root(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_to_root( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_to_root(self.0) } + } + fn to_parent(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_cursor_to_parent( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_cursor_to_parent(self.0) } + } +} +impl VtkHyperTreeGridNonOrientedGeometryCursor +for vtkHyperTreeGridNonOrientedGeometryCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_safe_down_cast(self.0, o) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_new(self.0) } + } + fn clone(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_clone( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_clone(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn has_tree(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_has_tree(self.0) } + } + fn get_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_tree(self.0) } + } + fn get_vertex_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_vertex_id(self.0) } + } + fn get_global_node_index(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_global_node_index( + self.0, + ) + } + } + fn get_dimension(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_dimension(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_number_of_children( + self.0, + ) + } + } + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_start( + self.0, + index, + ) + } + } + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_global_index_from_local( + self.0, + index, + ) + } + } + fn set_mask(&mut self, state: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask( + sself: *mut core::ffi::c_void, + state: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_set_mask(self.0, state) + } + } + fn is_masked(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_masked(self.0) } + } + fn is_leaf(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_leaf(self.0) } + } + fn subdivide_leaf(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_subdivide_leaf(self.0) + } + } + fn is_root(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_is_root(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_get_level(self.0) } + } + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child( + sself: *mut core::ffi::c_void, + ichild: core::ffi::c_uchar, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_child(self.0, ichild) + } + } + fn to_root(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_root(self.0) } + } + fn to_parent(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_non_oriented_geometry_cursor_to_parent(self.0) } + } +} +impl VtkHyperTreeGridNonOrientedMooreSuperCursor +for vtkHyperTreeGridNonOrientedMooreSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_safe_down_cast(self.0, o) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_new_instance(self.0) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_moore_super_cursor_new(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn get_corner_cursors( + &mut self, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_get_corner_cursors( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_get_corner_cursors( + self.0, + p0, + p1, + p2, + ) + } + } +} +impl VtkHyperTreeGridNonOrientedMooreSuperCursorLight +for vtkHyperTreeGridNonOrientedMooreSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_safe_down_cast( + self.0, + o, + ) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_new_instance( + self.0, + ) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_new(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn get_corner_cursors( + &mut self, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_get_corner_cursors( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_uint, + p1: core::ffi::c_uint, + p2: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_moore_super_cursor_light_get_corner_cursors( + self.0, + p0, + p1, + p2, + ) + } + } +} +impl VtkHyperTreeGridNonOrientedVonNeumannSuperCursor +for vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_safe_down_cast( + self.0, + o, + ) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_new_instance( + self.0, + ) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_new(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } +} +impl VtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight +for vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_safe_down_cast( + self.0, + o, + ) + } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_new_instance( + self.0, + ) + } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_new(self.0) + } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_non_oriented_von_neumann_super_cursor_light_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } +} +impl VtkHyperTreeGridOrientedCursor for vtkHyperTreeGridOrientedCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_new(self.0) } + } + fn clone(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_clone( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_clone(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn get_grid(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_grid( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_grid(self.0) } + } + fn has_tree(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_has_tree( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_has_tree(self.0) } + } + fn get_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_tree(self.0) } + } + fn get_vertex_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_vertex_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_vertex_id(self.0) } + } + fn get_global_node_index(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_global_node_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_global_node_index(self.0) } + } + fn get_dimension(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_dimension(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_number_of_children(self.0) } + } + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_set_global_index_start( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_cursor_set_global_index_start(self.0, index) + } + } + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_cursor_set_global_index_from_local( + self.0, + index, + ) + } + } + fn set_mask(&mut self, state: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_set_mask( + sself: *mut core::ffi::c_void, + state: bool, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_set_mask(self.0, state) } + } + fn is_masked(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_is_masked( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_is_masked(self.0) } + } + fn is_leaf(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_is_leaf( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_is_leaf(self.0) } + } + fn subdivide_leaf(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_subdivide_leaf(self.0) } + } + fn is_root(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_is_root( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_is_root(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_get_level(self.0) } + } + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_cursor_to_child( + sself: *mut core::ffi::c_void, + ichild: core::ffi::c_uchar, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_cursor_to_child(self.0, ichild) } + } +} +impl VtkHyperTreeGridOrientedGeometryCursor for vtkHyperTreeGridOrientedGeometryCursor { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_new(self.0) } + } + fn clone(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_clone( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_clone(self.0) } + } + fn initialize( + &mut self, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + sself: *mut core::ffi::c_void, + grid: *mut core::ffi::c_void, + treeIndex: core::ffi::c_longlong, + create: bool, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_initialize( + self.0, + grid, + treeIndex, + create, + ) + } + } + fn has_tree(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_has_tree(self.0) } + } + fn get_tree(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_tree( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_tree(self.0) } + } + fn get_vertex_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_vertex_id(self.0) } + } + fn get_global_node_index(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_get_global_node_index(self.0) + } + } + fn get_dimension(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_dimension(self.0) } + } + fn get_number_of_children(&mut self) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uchar; + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_get_number_of_children(self.0) + } + } + fn set_global_index_start(&mut self, index: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_start( + self.0, + index, + ) + } + } + fn set_global_index_from_local(&mut self, index: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ); + } + unsafe { + vtk_hyper_tree_grid_oriented_geometry_cursor_set_global_index_from_local( + self.0, + index, + ) + } + } + fn set_mask(&mut self, state: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask( + sself: *mut core::ffi::c_void, + state: bool, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_set_mask(self.0, state) } + } + fn is_masked(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_is_masked(self.0) } + } + fn is_leaf(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_is_leaf(self.0) } + } + fn subdivide_leaf(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_subdivide_leaf(self.0) } + } + fn is_root(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_is_root( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_is_root(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_get_level(self.0) } + } + fn to_child(&mut self, ichild: core::ffi::c_uchar) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_oriented_geometry_cursor_to_child( + sself: *mut core::ffi::c_void, + ichild: core::ffi::c_uchar, + ); + } + unsafe { vtk_hyper_tree_grid_oriented_geometry_cursor_to_child(self.0, ichild) } + } +} +impl VtkImageData for vtkImageData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_new_instance(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_copy_structure(self.0, ds) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_data_object_type(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_image_data_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_image_data_get_number_of_cells(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_image_data_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_image_data_get_number_of_points(self.0) } + } + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_cell(self.0, cellId) } + } + fn find_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_image_data_find_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_image_data_find_point(self.0, x, y, z) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_cell_type(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_get_point_cells(self.0, ptId, cellIds) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_max_cell_size(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_image_data_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_image_data_initialize(self.0) } + } + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_is_point_visible( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_is_point_visible(self.0, ptId) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_image_data_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_image_data_is_cell_visible(self.0, cellId) } + } + fn has_any_blank_points(&mut self) -> bool { + unsafe extern "C" { + fn vtk_image_data_has_any_blank_points( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_image_data_has_any_blank_points(self.0) } + } + fn has_any_blank_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_image_data_has_any_blank_cells(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_image_data_has_any_blank_cells(self.0) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_set_dimensions(self.0, i, j, k) } + } + fn get_voxel_gradient( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_get_voxel_gradient( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + s: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_get_voxel_gradient(self.0, i, j, k, s, g) } + } + fn get_data_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_data_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_data_dimension(self.0) } + } + fn set_extent( + &mut self, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_extent( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_int, + x2: core::ffi::c_int, + y1: core::ffi::c_int, + y2: core::ffi::c_int, + z1: core::ffi::c_int, + z2: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_set_extent(self.0, x1, x2, y1, y2, z1, z2) } + } + fn get_scalar_type_min( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type_min( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_image_data_get_scalar_type_min(self.0, meta_data) } + } + fn get_scalar_type_max( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type_max( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_image_data_get_scalar_type_max(self.0, meta_data) } + } + fn get_scalar_size( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_scalar_size( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_scalar_size(self.0, meta_data) } + } + fn get_scalar_index( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_image_data_get_scalar_index( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_image_data_get_scalar_index(self.0, x, y, z) } + } + fn get_scalar_component_as_float( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_float { + unsafe extern "C" { + fn vtk_image_data_get_scalar_component_as_float( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_float; + } + unsafe { + vtk_image_data_get_scalar_component_as_float(self.0, x, y, z, component) + } + } + fn set_scalar_component_from_float( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_float, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_scalar_component_from_float( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_float, + ); + } + unsafe { + vtk_image_data_set_scalar_component_from_float(self.0, x, y, z, component, v) + } + } + fn get_scalar_component_as_double( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_image_data_get_scalar_component_as_double( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { + vtk_image_data_get_scalar_component_as_double(self.0, x, y, z, component) + } + } + fn set_scalar_component_from_double( + &mut self, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_scalar_component_from_double( + sself: *mut core::ffi::c_void, + x: core::ffi::c_int, + y: core::ffi::c_int, + z: core::ffi::c_int, + component: core::ffi::c_int, + v: core::ffi::c_double, + ); + } + unsafe { + vtk_image_data_set_scalar_component_from_double( + self.0, + x, + y, + z, + component, + v, + ) + } + } + fn allocate_scalars( + &mut self, + dataType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_allocate_scalars( + sself: *mut core::ffi::c_void, + dataType: core::ffi::c_int, + numComponents: core::ffi::c_int, + ); + } + unsafe { vtk_image_data_allocate_scalars(self.0, dataType, numComponents) } + } + fn copy_and_cast_from( + &mut self, + inData: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_and_cast_from( + sself: *mut core::ffi::c_void, + inData: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { + vtk_image_data_copy_and_cast_from(self.0, inData, x0, x1, y0, y1, z0, z1) + } + } + fn set_spacing( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_spacing( + sself: *mut core::ffi::c_void, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_set_spacing(self.0, i, j, k) } + } + fn set_origin( + &mut self, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_origin( + sself: *mut core::ffi::c_void, + i: core::ffi::c_double, + j: core::ffi::c_double, + k: core::ffi::c_double, + ); + } + unsafe { vtk_image_data_set_origin(self.0, i, j, k) } + } + fn get_direction_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_direction_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_direction_matrix(self.0) } + } + fn set_direction_matrix(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_image_data_set_direction_matrix( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_set_direction_matrix(self.0, m) } + } + fn get_index_to_physical_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_index_to_physical_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_index_to_physical_matrix(self.0) } + } + fn get_physical_to_index_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_physical_to_index_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_physical_to_index_matrix(self.0) } + } + fn set_scalar_type( + &mut self, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_scalar_type( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_set_scalar_type(self.0, p0, meta_data) } + } + fn get_scalar_type( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_scalar_type(self.0, meta_data) } + } + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_image_data_has_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_image_data_has_scalar_type(self.0, meta_data) } + } + fn get_scalar_type_as_string(&mut self) -> &str { + unsafe extern "C" { + fn vtk_image_data_get_scalar_type_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_image_data_get_scalar_type_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_number_of_scalar_components( + &mut self, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_set_number_of_scalar_components( + sself: *mut core::ffi::c_void, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_set_number_of_scalar_components(self.0, n, meta_data) } + } + fn get_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_number_of_scalar_components( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_number_of_scalar_components(self.0, meta_data) } + } + fn has_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_image_data_has_number_of_scalar_components( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_image_data_has_number_of_scalar_components(self.0, meta_data) } + } + fn copy_information_from_pipeline( + &mut self, + information: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_information_from_pipeline( + sself: *mut core::ffi::c_void, + information: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_copy_information_from_pipeline(self.0, information) } + } + fn copy_information_to_pipeline( + &mut self, + information: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_data_copy_information_to_pipeline( + sself: *mut core::ffi::c_void, + information: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_data_copy_information_to_pipeline(self.0, information) } + } + fn prepare_for_new_data(&mut self) -> () { + unsafe extern "C" { + fn vtk_image_data_prepare_for_new_data(sself: *mut core::ffi::c_void); + } + unsafe { vtk_image_data_prepare_for_new_data(self.0) } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_image_data_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_image_data_get_extent_type(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_data_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_data_get_data(self.0, info) } + } +} +impl VtkImageTransform for vtkImageTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_transform_new_instance(self.0) } + } + fn transform_point_set( + &mut self, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_transform_transform_point_set( + sself: *mut core::ffi::c_void, + im: *mut core::ffi::c_void, + ps: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_transform_transform_point_set(self.0, im, ps) } + } + fn transform_points( + &mut self, + m4: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_image_transform_transform_points( + sself: *mut core::ffi::c_void, + m4: *mut core::ffi::c_void, + da: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_transform_transform_points(self.0, m4, da) } + } +} +impl VtkImplicitBoolean for vtkImplicitBoolean { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_boolean_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_boolean_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_boolean_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_boolean_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_boolean_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_boolean_new(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_boolean_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_boolean_get_m_time(self.0) } + } + fn add_function(&mut self, in_: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_add_function( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_add_function(self.0, in_) } + } + fn remove_function(&mut self, in_: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_remove_function( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_remove_function(self.0, in_) } + } + fn get_function(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_boolean_get_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_boolean_get_function(self.0) } + } + fn set_operation_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type(self.0, _arg) } + } + fn get_operation_type_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_boolean_get_operation_type_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_boolean_get_operation_type_min_value(self.0) } + } + fn get_operation_type_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_boolean_get_operation_type_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_boolean_get_operation_type_max_value(self.0) } + } + fn get_operation_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_boolean_get_operation_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_boolean_get_operation_type(self.0) } + } + fn set_operation_type_to_union(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type_to_union( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type_to_union(self.0) } + } + fn set_operation_type_to_intersection(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type_to_intersection( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type_to_intersection(self.0) } + } + fn set_operation_type_to_difference(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type_to_difference( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type_to_difference(self.0) } + } + fn set_operation_type_to_union_of_magnitudes(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_boolean_set_operation_type_to_union_of_magnitudes(self.0) } + } + fn get_operation_type_as_string(&mut self) -> &str { + unsafe extern "C" { + fn vtk_implicit_boolean_get_operation_type_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_implicit_boolean_get_operation_type_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } +} +impl VtkImplicitDataSet for vtkImplicitDataSet { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_data_set_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_data_set_new(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_data_set_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_data_set_get_m_time(self.0) } + } + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_set_data_set( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_data_set_set_data_set(self.0, p0) } + } + fn get_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_data_set_get_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_data_set_get_data_set(self.0) } + } + fn set_out_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_set_out_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_data_set_set_out_value(self.0, _arg) } + } + fn get_out_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_data_set_get_out_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_data_set_get_out_value(self.0) } + } + fn set_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_data_set_set_out_gradient( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_data_set_set_out_gradient(self.0, _arg1, _arg2, _arg3) } + } +} +impl VtkImplicitFunctionCollection for vtkImplicitFunctionCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_function_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_function_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_function_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_function_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_function_collection_add_item(self.0, p0) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_function_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_function_collection_get_next_item(self.0) } + } +} +impl VtkImplicitHalo for vtkImplicitHalo { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_halo_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_halo_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_halo_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_halo_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_halo_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_halo_new_instance(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_halo_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_halo_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_fade_out(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_halo_set_fade_out( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_halo_set_fade_out(self.0, _arg) } + } + fn get_fade_out(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_halo_get_fade_out( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_halo_get_fade_out(self.0) } + } +} +impl VtkImplicitSelectionLoop for vtkImplicitSelectionLoop { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_selection_loop_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_selection_loop_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_selection_loop_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_selection_loop_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_selection_loop_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_selection_loop_new(self.0) } + } + fn set_loop(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_set_loop( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_selection_loop_set_loop(self.0, p0) } + } + fn get_loop(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_selection_loop_get_loop( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_selection_loop_get_loop(self.0) } + } + fn set_automatic_normal_generation(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_set_automatic_normal_generation( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_implicit_selection_loop_set_automatic_normal_generation(self.0, _arg) + } + } + fn get_automatic_normal_generation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_selection_loop_get_automatic_normal_generation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_selection_loop_get_automatic_normal_generation(self.0) } + } + fn automatic_normal_generation_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_automatic_normal_generation_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_selection_loop_automatic_normal_generation_on(self.0) } + } + fn automatic_normal_generation_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_automatic_normal_generation_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_selection_loop_automatic_normal_generation_off(self.0) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_selection_loop_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_selection_loop_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_selection_loop_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_selection_loop_get_m_time(self.0) } + } +} +impl VtkImplicitSum for vtkImplicitSum { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_sum_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_sum_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_sum_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_sum_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_sum_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_sum_new_instance(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_sum_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_sum_get_m_time(self.0) } + } + fn add_function( + &mut self, + in_: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_add_function( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_sum_add_function(self.0, in_, weight) } + } + fn remove_all_functions(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_remove_all_functions(sself: *mut core::ffi::c_void); + } + unsafe { vtk_implicit_sum_remove_all_functions(self.0) } + } + fn set_function_weight( + &mut self, + f: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_set_function_weight( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + weight: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_sum_set_function_weight(self.0, f, weight) } + } + fn set_normalize_by_weight(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_set_normalize_by_weight( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_implicit_sum_set_normalize_by_weight(self.0, _arg) } + } + fn get_normalize_by_weight(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_implicit_sum_get_normalize_by_weight( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_implicit_sum_get_normalize_by_weight(self.0) } + } + fn normalize_by_weight_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_normalize_by_weight_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_implicit_sum_normalize_by_weight_on(self.0) } + } + fn normalize_by_weight_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_implicit_sum_normalize_by_weight_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_implicit_sum_normalize_by_weight_off(self.0) } + } +} +impl VtkImplicitVolume for vtkImplicitVolume { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_volume_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_volume_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_volume_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_volume_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_volume_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_volume_new(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_volume_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_volume_get_m_time(self.0) } + } + fn set_volume(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_set_volume( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_volume_set_volume(self.0, p0) } + } + fn get_volume(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_volume_get_volume( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_volume_get_volume(self.0) } + } + fn set_out_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_set_out_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_volume_set_out_value(self.0, _arg) } + } + fn get_out_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_implicit_volume_get_out_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_implicit_volume_get_out_value(self.0) } + } + fn set_out_gradient( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_volume_set_out_gradient( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_volume_set_out_gradient(self.0, _arg1, _arg2, _arg3) } + } +} +impl VtkImplicitWindowFunction for vtkImplicitWindowFunction { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_window_function_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_window_function_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_window_function_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_window_function_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_window_function_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_window_function_new(self.0) } + } + fn set_implicit_function(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_set_implicit_function( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_window_function_set_implicit_function(self.0, p0) } + } + fn get_implicit_function(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_implicit_window_function_get_implicit_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_implicit_window_function_get_implicit_function(self.0) } + } + fn set_window_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_set_window_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_set_window_range(self.0, _arg1, _arg2) } + } + fn set_window_values( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_set_window_values( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_implicit_window_function_set_window_values(self.0, _arg1, _arg2) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_implicit_window_function_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_implicit_window_function_get_m_time(self.0) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_implicit_window_function_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_implicit_window_function_register(self.0, o) } + } +} +impl VtkInEdgeIterator for vtkInEdgeIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_new_instance(self.0) } + } + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_in_edge_iterator_initialize( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ); + } + unsafe { vtk_in_edge_iterator_initialize(self.0, g, v) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_get_graph(self.0) } + } + fn get_vertex(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_in_edge_iterator_get_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_in_edge_iterator_get_vertex(self.0) } + } + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_in_edge_iterator_next_graph_edge( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_in_edge_iterator_next_graph_edge(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_in_edge_iterator_has_next(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_in_edge_iterator_has_next(self.0) } + } +} +impl VtkIncrementalOctreeNode for vtkIncrementalOctreeNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_new(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_get_number_of_points(self.0) } + } + fn get_point_id_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_point_id_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_get_point_id_set(self.0) } + } + fn delete_child_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_delete_child_nodes( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_node_delete_child_nodes(self.0) } + } + fn set_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_set_bounds( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ); + } + unsafe { vtk_incremental_octree_node_set_bounds(self.0, x1, x2, y1, y2, z1, z2) } + } + fn is_leaf(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_is_leaf( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_is_leaf(self.0) } + } + fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_child( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_get_child(self.0, i) } + } + fn export_all_point_ids_by_insertion( + &mut self, + idList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_node_export_all_point_ids_by_insertion( + sself: *mut core::ffi::c_void, + idList: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_incremental_octree_node_export_all_point_ids_by_insertion(self.0, idList) + } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_get_number_of_levels(self.0) } + } + fn get_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_node_get_id(self.0) } + } + fn get_point_ids(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_node_get_point_ids( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_node_get_point_ids(self.0) } + } +} +impl VtkIncrementalOctreePointLocator for vtkIncrementalOctreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_new(self.0) } + } + fn set_max_points_per_leaf(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_set_max_points_per_leaf( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_incremental_octree_point_locator_set_max_points_per_leaf(self.0, _arg) + } + } + fn get_max_points_per_leaf_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_point_locator_get_max_points_per_leaf_min_value( + self.0, + ) + } + } + fn get_max_points_per_leaf_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_incremental_octree_point_locator_get_max_points_per_leaf_max_value( + self.0, + ) + } + } + fn get_max_points_per_leaf(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_max_points_per_leaf( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_max_points_per_leaf(self.0) } + } + fn set_build_cubic_octree(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_set_build_cubic_octree( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_incremental_octree_point_locator_set_build_cubic_octree(self.0, _arg) + } + } + fn get_build_cubic_octree(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_build_cubic_octree( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_build_cubic_octree(self.0) } + } + fn build_cubic_octree_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_build_cubic_octree_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_build_cubic_octree_on(self.0) } + } + fn build_cubic_octree_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_build_cubic_octree_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_build_cubic_octree_off(self.0) } + } + fn get_locator_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_locator_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_get_locator_points(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_initialize( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_initialize(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_free_search_structure(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_number_of_points(self.0) } + } + fn get_number_of_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_number_of_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_number_of_nodes(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + polysData: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_incremental_octree_point_locator_generate_representation( + self.0, + level, + polysData, + ) + } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_build_locator( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_incremental_octree_point_locator_build_locator(self.0) } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_incremental_octree_point_locator_find_closest_point(self.0, x, y, z) + } + } + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_incremental_octree_point_locator_is_inserted_point(self.0, x, y, z) + } + } + fn get_root(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_root( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_incremental_octree_point_locator_get_root(self.0) } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_incremental_octree_point_locator_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_incremental_octree_point_locator_get_number_of_levels(self.0) } + } +} +impl VtkIterativeClosestPointTransform for vtkIterativeClosestPointTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_new_instance(self.0) } + } + fn set_source(&mut self, source: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_source( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_set_source(self.0, source) } + } + fn set_target(&mut self, target: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_target( + sself: *mut core::ffi::c_void, + target: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_set_target(self.0, target) } + } + fn get_source(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_source( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_get_source(self.0) } + } + fn get_target(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_target( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_get_target(self.0) } + } + fn set_locator(&mut self, locator: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_locator( + sself: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_set_locator(self.0, locator) } + } + fn get_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_get_locator(self.0) } + } + fn set_maximum_number_of_iterations(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_maximum_number_of_iterations( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_maximum_number_of_iterations( + self.0, + _arg, + ) + } + } + fn get_maximum_number_of_iterations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_maximum_number_of_iterations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_maximum_number_of_iterations( + self.0, + ) + } + } + fn get_number_of_iterations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_number_of_iterations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_iterative_closest_point_transform_get_number_of_iterations(self.0) } + } + fn set_check_mean_distance(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_check_mean_distance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_check_mean_distance(self.0, _arg) + } + } + fn get_check_mean_distance(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_check_mean_distance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_iterative_closest_point_transform_get_check_mean_distance(self.0) } + } + fn check_mean_distance_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_check_mean_distance_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_check_mean_distance_on(self.0) } + } + fn check_mean_distance_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_check_mean_distance_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_check_mean_distance_off(self.0) } + } + fn set_mean_distance_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_mean_distance_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_mean_distance_mode(self.0, _arg) + } + } + fn get_mean_distance_mode_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_mean_distance_mode_min_value( + self.0, + ) + } + } + fn get_mean_distance_mode_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_mean_distance_mode_max_value( + self.0, + ) + } + } + fn get_mean_distance_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_iterative_closest_point_transform_get_mean_distance_mode(self.0) } + } + fn set_mean_distance_mode_to_rms(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_mean_distance_mode_to_rms(self.0) + } + } + fn set_mean_distance_mode_to_absolute_value(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_mean_distance_mode_to_absolute_value( + self.0, + ) + } + } + fn get_mean_distance_mode_as_string(&mut self) -> &str { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_iterative_closest_point_transform_get_mean_distance_mode_as_string( + self.0, + ) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_maximum_mean_distance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_maximum_mean_distance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_maximum_mean_distance(self.0, _arg) + } + } + fn get_maximum_mean_distance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_maximum_mean_distance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_iterative_closest_point_transform_get_maximum_mean_distance(self.0) + } + } + fn get_mean_distance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_mean_distance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_iterative_closest_point_transform_get_mean_distance(self.0) } + } + fn set_maximum_number_of_landmarks(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_maximum_number_of_landmarks( + self.0, + _arg, + ) + } + } + fn get_maximum_number_of_landmarks(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_maximum_number_of_landmarks(self.0) + } + } + fn set_start_by_matching_centroids(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_set_start_by_matching_centroids( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_iterative_closest_point_transform_set_start_by_matching_centroids( + self.0, + _arg, + ) + } + } + fn get_start_by_matching_centroids(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_start_by_matching_centroids( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_iterative_closest_point_transform_get_start_by_matching_centroids(self.0) + } + } + fn start_by_matching_centroids_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_start_by_matching_centroids_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_iterative_closest_point_transform_start_by_matching_centroids_on(self.0) + } + } + fn start_by_matching_centroids_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_start_by_matching_centroids_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_iterative_closest_point_transform_start_by_matching_centroids_off(self.0) + } + } + fn get_landmark_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_get_landmark_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_get_landmark_transform(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_inverse( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_iterative_closest_point_transform_inverse(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_iterative_closest_point_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_iterative_closest_point_transform_make_transform(self.0) } + } +} +impl VtkKdNode for vtkKdNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_new(self.0) } + } + fn set_dim(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_dim( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_set_dim(self.0, _arg) } + } + fn get_dim(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_dim(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_dim(self.0) } + } + fn get_division_position(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_division_position( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kd_node_get_division_position(self.0) } + } + fn set_number_of_points(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_number_of_points( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_set_number_of_points(self.0, _arg) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_number_of_points(self.0) } + } + fn set_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_bounds( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_bounds(self.0, x1, x2, y1, y2, z1, z2) } + } + fn set_data_bounds( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_data_bounds( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + ); + } + unsafe { vtk_kd_node_set_data_bounds(self.0, x1, x2, y1, y2, z1, z2) } + } + fn set_id(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_id(sself: *mut core::ffi::c_void, _arg: core::ffi::c_int); + } + unsafe { vtk_kd_node_set_id(self.0, _arg) } + } + fn get_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_id(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_id(self.0) } + } + fn get_min_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_min_id(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_min_id(self.0) } + } + fn get_max_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_get_max_id(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_get_max_id(self.0) } + } + fn set_min_id(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_min_id( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_set_min_id(self.0, _arg) } + } + fn set_max_id(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_max_id( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_set_max_id(self.0, _arg) } + } + fn add_child_nodes( + &mut self, + left: *mut core::ffi::c_void, + right: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_node_add_child_nodes( + sself: *mut core::ffi::c_void, + left: *mut core::ffi::c_void, + right: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_node_add_child_nodes(self.0, left, right) } + } + fn delete_child_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_node_delete_child_nodes(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_node_delete_child_nodes(self.0) } + } + fn get_left(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_get_left( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_get_left(self.0) } + } + fn set_left(&mut self, left: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_left( + sself: *mut core::ffi::c_void, + left: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_node_set_left(self.0, left) } + } + fn get_right(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_get_right( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_get_right(self.0) } + } + fn set_right(&mut self, right: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_right( + sself: *mut core::ffi::c_void, + right: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_node_set_right(self.0, right) } + } + fn get_up(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_node_get_up( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_node_get_up(self.0) } + } + fn set_up(&mut self, up: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_node_set_up( + sself: *mut core::ffi::c_void, + up: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_node_set_up(self.0, up) } + } + fn intersects_box( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_intersects_box( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_node_intersects_box(self.0, x1, x2, y1, y2, z1, z2, useDataBounds) + } + } + fn intersects_sphere_2( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_intersects_sphere_2( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + rSquared: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_node_intersects_sphere_2(self.0, x, y, z, rSquared, useDataBounds) + } + } + fn intersects_region( + &mut self, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_intersects_region( + sself: *mut core::ffi::c_void, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_intersects_region(self.0, pi, useDataBounds) } + } + fn contains_box( + &mut self, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_contains_box( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + x2: core::ffi::c_double, + y1: core::ffi::c_double, + y2: core::ffi::c_double, + z1: core::ffi::c_double, + z2: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_kd_node_contains_box(self.0, x1, x2, y1, y2, z1, z2, useDataBounds) + } + } + fn contains_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_node_contains_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_node_contains_point(self.0, x, y, z, useDataBounds) } + } + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_distance_2_to_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_kd_node_get_distance_2_to_boundary(self.0, x, y, z, useDataBounds) } + } + fn get_distance_2_to_inner_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_node_get_distance_2_to_inner_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_kd_node_get_distance_2_to_inner_boundary(self.0, x, y, z) } + } + fn print_node(&mut self, depth: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_print_node( + sself: *mut core::ffi::c_void, + depth: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_print_node(self.0, depth) } + } + fn print_verbose_node(&mut self, depth: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_node_print_verbose_node( + sself: *mut core::ffi::c_void, + depth: core::ffi::c_int, + ); + } + unsafe { vtk_kd_node_print_verbose_node(self.0, depth) } + } +} +impl VtkKdTree for vtkKdTree { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_new(self.0) } + } + fn timing_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_timing_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_timing_on(self.0) } + } + fn timing_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_timing_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_timing_off(self.0) } + } + fn set_timing(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_timing( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_timing(self.0, _arg) } + } + fn get_timing(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_timing(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_timing(self.0) } + } + fn set_min_cells(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_min_cells( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_min_cells(self.0, _arg) } + } + fn get_min_cells(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_min_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_min_cells(self.0) } + } + fn get_number_of_regions_or_less(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_number_of_regions_or_less( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_number_of_regions_or_less(self.0) } + } + fn set_number_of_regions_or_less(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_number_of_regions_or_less( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_number_of_regions_or_less(self.0, _arg) } + } + fn get_number_of_regions_or_more(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_number_of_regions_or_more( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_number_of_regions_or_more(self.0) } + } + fn set_number_of_regions_or_more(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_number_of_regions_or_more( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_number_of_regions_or_more(self.0, _arg) } + } + fn get_fudge_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_kd_tree_get_fudge_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_kd_tree_get_fudge_factor(self.0) } + } + fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_fudge_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_kd_tree_set_fudge_factor(self.0, _arg) } + } + fn get_cuts(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_cuts( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_cuts(self.0) } + } + fn set_cuts(&mut self, cuts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_cuts( + sself: *mut core::ffi::c_void, + cuts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_set_cuts(self.0, cuts) } + } + fn omit_x_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_x_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_x_partitioning(self.0) } + } + fn omit_y_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_y_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_y_partitioning(self.0) } + } + fn omit_z_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_z_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_z_partitioning(self.0) } + } + fn omit_xy_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_xy_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_xy_partitioning(self.0) } + } + fn omit_yz_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_yz_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_yz_partitioning(self.0) } + } + fn omit_zx_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_zx_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_zx_partitioning(self.0) } + } + fn omit_no_partitioning(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_omit_no_partitioning(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_omit_no_partitioning(self.0) } + } + fn set_data_set(&mut self, set: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_data_set( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_set_data_set(self.0, set) } + } + fn add_data_set(&mut self, set: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_add_data_set( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_add_data_set(self.0, set) } + } + fn remove_data_set(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_remove_data_set( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_remove_data_set(self.0, index) } + } + fn remove_all_data_sets(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_remove_all_data_sets(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_remove_all_data_sets(self.0) } + } + fn get_number_of_data_sets(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_number_of_data_sets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_number_of_data_sets(self.0) } + } + fn get_data_set(&mut self, n: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_data_set( + sself: *mut core::ffi::c_void, + n: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_data_set(self.0, n) } + } + fn get_data_sets(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_data_sets( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_data_sets(self.0) } + } + fn get_data_set_index(&mut self, set: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_data_set_index( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_data_set_index(self.0, set) } + } + fn get_number_of_regions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_number_of_regions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_number_of_regions(self.0) } + } + fn print_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_print_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_print_tree(self.0) } + } + fn print_verbose_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_print_verbose_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_print_verbose_tree(self.0) } + } + fn print_region(&mut self, id: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_print_region( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_print_region(self.0, id) } + } + fn set_include_region_boundary_cells(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_include_region_boundary_cells( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_kd_tree_set_include_region_boundary_cells(self.0, _arg) } + } + fn get_include_region_boundary_cells(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_include_region_boundary_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_include_region_boundary_cells(self.0) } + } + fn include_region_boundary_cells_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_include_region_boundary_cells_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_include_region_boundary_cells_on(self.0) } + } + fn include_region_boundary_cells_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_include_region_boundary_cells_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_include_region_boundary_cells_off(self.0) } + } + fn delete_cell_lists(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_delete_cell_lists(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_delete_cell_lists(self.0) } + } + fn get_cell_list(&mut self, regionID: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_cell_list( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_cell_list(self.0, regionID) } + } + fn get_boundary_cell_list( + &mut self, + regionID: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_boundary_cell_list( + sself: *mut core::ffi::c_void, + regionID: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_boundary_cell_list(self.0, regionID) } + } + fn get_cell_lists( + &mut self, + regions: *mut core::ffi::c_void, + set: core::ffi::c_int, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_kd_tree_get_cell_lists( + sself: *mut core::ffi::c_void, + regions: *mut core::ffi::c_void, + set: core::ffi::c_int, + inRegionCells: *mut core::ffi::c_void, + onBoundaryCells: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_kd_tree_get_cell_lists( + self.0, + regions, + set, + inRegionCells, + onBoundaryCells, + ) + } + } + fn get_region_containing_cell( + &mut self, + set: *mut core::ffi::c_void, + cellID: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_region_containing_cell( + sself: *mut core::ffi::c_void, + set: *mut core::ffi::c_void, + cellID: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_region_containing_cell(self.0, set, cellID) } + } + fn get_region_containing_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_region_containing_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_region_containing_point(self.0, x, y, z) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_build_locator(self.0) } + } + fn build_locator_from_points(&mut self, pointset: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_kd_tree_build_locator_from_points( + sself: *mut core::ffi::c_void, + pointset: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_build_locator_from_points(self.0, pointset) } + } + fn build_map_for_duplicate_points( + &mut self, + tolerance: core::ffi::c_float, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_build_map_for_duplicate_points( + sself: *mut core::ffi::c_void, + tolerance: core::ffi::c_float, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_build_map_for_duplicate_points(self.0, tolerance) } + } + fn get_points_in_region( + &mut self, + regionId: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_get_points_in_region( + sself: *mut core::ffi::c_void, + regionId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_get_points_in_region(self.0, regionId) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_free_search_structure(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_free_search_structure(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_generate_representation(self.0, level, pd) } + } + fn generate_representation_using_data_bounds_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_generate_representation_using_data_bounds_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_generate_representation_using_data_bounds_on(self.0) } + } + fn generate_representation_using_data_bounds_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_generate_representation_using_data_bounds_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_generate_representation_using_data_bounds_off(self.0) } + } + fn set_generate_representation_using_data_bounds( + &mut self, + _arg: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_set_generate_representation_using_data_bounds( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_kd_tree_set_generate_representation_using_data_bounds(self.0, _arg) + } + } + fn get_generate_representation_using_data_bounds(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_get_generate_representation_using_data_bounds( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_get_generate_representation_using_data_bounds(self.0) } + } + fn new_geometry(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_kd_tree_new_geometry( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_kd_tree_new_geometry(self.0) } + } + fn invalidate_geometry(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_invalidate_geometry(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_invalidate_geometry(self.0) } + } + fn copy_tree(&mut self, kd: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_copy_tree( + sself: *mut core::ffi::c_void, + kd: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_copy_tree(self.0, kd) } + } +} +impl VtkKdTreePointLocator for vtkKdTreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_point_locator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_kd_tree_point_locator_new(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_point_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_kd_tree_point_locator_build_locator(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_kd_tree_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_kd_tree_point_locator_generate_representation(self.0, level, pd) } + } +} +impl VtkLagrangeCurve for vtkLagrangeCurve { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_curve_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_curve_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_curve_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_curve_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_curve_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_curve_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_curve_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_curve_get_cell_type(self.0) } + } +} +impl VtkLagrangeHexahedron for vtkLagrangeHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_hexahedron_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_face(self.0, faceId) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_edge_cell(self.0) } + } + fn get_face_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_face_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_face_cell(self.0) } + } + fn get_interpolation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_hexahedron_get_interpolation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_hexahedron_get_interpolation(self.0) } + } +} +impl VtkLagrangeInterpolation for vtkLagrangeInterpolation { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_interpolation_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_interpolation_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_interpolation_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_interpolation_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_interpolation_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_interpolation_new_instance(self.0) } + } +} +impl VtkLagrangeQuadrilateral for vtkLagrangeQuadrilateral { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_quadrilateral_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_get_edge(self.0, edgeId) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_quadrilateral_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_quadrilateral_get_edge_cell(self.0) } + } +} +impl VtkLagrangeTetra for vtkLagrangeTetra { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_tetra_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_get_face(self.0, faceId) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_get_edge_cell(self.0) } + } + fn get_face_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_tetra_get_face_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_tetra_get_face_cell(self.0) } + } +} +impl VtkLagrangeTriangle for vtkLagrangeTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_triangle_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_get_edge(self.0, edgeId) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_triangle_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_triangle_get_edge_cell(self.0) } + } +} +impl VtkLagrangeWedge for vtkLagrangeWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_lagrange_wedge_get_cell_type(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_face(self.0, faceId) } + } + fn get_boundary_quad(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_boundary_quad( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_boundary_quad(self.0) } + } + fn get_boundary_tri(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_boundary_tri( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_boundary_tri(self.0) } + } + fn get_edge_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_edge_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_edge_cell(self.0) } + } + fn get_interpolation(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_lagrange_wedge_get_interpolation( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_lagrange_wedge_get_interpolation(self.0) } + } +} +impl VtkLine for vtkLine { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_cell_type(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_line_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_line_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_line_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_triangulate(self.0, index, ptIds, pts) } + } + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_inflate( + sself: *mut core::ffi::c_void, + dist: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_inflate(self.0, dist) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_line_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_line_clip( + self.0, + value, + cellScalars, + locator, + lines, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkMeanValueCoordinatesInterpolator for vtkMeanValueCoordinatesInterpolator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mean_value_coordinates_interpolator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mean_value_coordinates_interpolator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mean_value_coordinates_interpolator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mean_value_coordinates_interpolator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mean_value_coordinates_interpolator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mean_value_coordinates_interpolator_new_instance(self.0) } + } +} +impl VtkMergePoints for vtkMergePoints { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_merge_points_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_merge_points_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_merge_points_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_merge_points_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_merge_points_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_merge_points_new_instance(self.0) } + } +} +impl VtkMolecule for vtkMolecule { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_new_instance(self.0) } + } + fn get_number_of_atoms(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_molecule_get_number_of_atoms( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_molecule_get_number_of_atoms(self.0) } + } + fn get_number_of_bonds(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_molecule_get_number_of_bonds( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_molecule_get_number_of_bonds(self.0) } + } + fn get_atom_atomic_number( + &mut self, + atomId: core::ffi::c_longlong, + ) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_molecule_get_atom_atomic_number( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_longlong, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_molecule_get_atom_atomic_number(self.0, atomId) } + } + fn set_atom_atomic_number( + &mut self, + atomId: core::ffi::c_longlong, + atomicNum: core::ffi::c_ushort, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_set_atom_atomic_number( + sself: *mut core::ffi::c_void, + atomId: core::ffi::c_longlong, + atomicNum: core::ffi::c_ushort, + ); + } + unsafe { vtk_molecule_set_atom_atomic_number(self.0, atomId, atomicNum) } + } + fn set_bond_order( + &mut self, + bondId: core::ffi::c_longlong, + order: core::ffi::c_ushort, + ) -> () { + unsafe extern "C" { + fn vtk_molecule_set_bond_order( + sself: *mut core::ffi::c_void, + bondId: core::ffi::c_longlong, + order: core::ffi::c_ushort, + ); + } + unsafe { vtk_molecule_set_bond_order(self.0, bondId, order) } + } + fn get_bond_order(&mut self, bondId: core::ffi::c_longlong) -> core::ffi::c_ushort { + unsafe extern "C" { + fn vtk_molecule_get_bond_order( + sself: *mut core::ffi::c_void, + bondId: core::ffi::c_longlong, + ) -> core::ffi::c_ushort; + } + unsafe { vtk_molecule_get_bond_order(self.0, bondId) } + } + fn get_bond_length(&mut self, bondId: core::ffi::c_longlong) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_molecule_get_bond_length( + sself: *mut core::ffi::c_void, + bondId: core::ffi::c_longlong, + ) -> core::ffi::c_double; + } + unsafe { vtk_molecule_get_bond_length(self.0, bondId) } + } + fn get_atomic_position_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atomic_position_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atomic_position_array(self.0) } + } + fn get_atomic_number_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atomic_number_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atomic_number_array(self.0) } + } + fn get_bond_orders_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_bond_orders_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_bond_orders_array(self.0) } + } + fn get_electronic_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_electronic_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_electronic_data(self.0) } + } + fn set_electronic_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_set_electronic_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_set_electronic_data(self.0, p0) } + } + fn shallow_copy(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_shallow_copy( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_shallow_copy(self.0, obj) } + } + fn deep_copy(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_deep_copy( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_deep_copy(self.0, obj) } + } + fn shallow_copy_structure(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_shallow_copy_structure( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_shallow_copy_structure(self.0, m) } + } + fn deep_copy_structure(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_deep_copy_structure( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_deep_copy_structure(self.0, m) } + } + fn shallow_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_shallow_copy_attributes( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_shallow_copy_attributes(self.0, m) } + } + fn deep_copy_attributes(&mut self, m: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_deep_copy_attributes( + sself: *mut core::ffi::c_void, + m: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_deep_copy_attributes(self.0, m) } + } + fn has_lattice(&mut self) -> bool { + unsafe extern "C" { + fn vtk_molecule_has_lattice(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_molecule_has_lattice(self.0) } + } + fn clear_lattice(&mut self) -> () { + unsafe extern "C" { + fn vtk_molecule_clear_lattice(sself: *mut core::ffi::c_void); + } + unsafe { vtk_molecule_clear_lattice(self.0) } + } + fn set_lattice(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_set_lattice( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_set_lattice(self.0, matrix) } + } + fn get_lattice(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_lattice( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_lattice(self.0) } + } + fn get_atom_ghost_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atom_ghost_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atom_ghost_array(self.0) } + } + fn allocate_atom_ghost_array(&mut self) -> () { + unsafe extern "C" { + fn vtk_molecule_allocate_atom_ghost_array(sself: *mut core::ffi::c_void); + } + unsafe { vtk_molecule_allocate_atom_ghost_array(self.0) } + } + fn get_bond_ghost_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_bond_ghost_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_bond_ghost_array(self.0) } + } + fn allocate_bond_ghost_array(&mut self) -> () { + unsafe extern "C" { + fn vtk_molecule_allocate_bond_ghost_array(sself: *mut core::ffi::c_void); + } + unsafe { vtk_molecule_allocate_bond_ghost_array(self.0) } + } + fn initialize( + &mut self, + atomPositions: *mut core::ffi::c_void, + atomicNumberArray: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_molecule_initialize( + sself: *mut core::ffi::c_void, + atomPositions: *mut core::ffi::c_void, + atomicNumberArray: *mut core::ffi::c_void, + atomData: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_molecule_initialize(self.0, atomPositions, atomicNumberArray, atomData) + } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_data(self.0, info) } + } + fn get_atom_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_atom_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_atom_data(self.0) } + } + fn get_bond_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_get_bond_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_get_bond_data(self.0) } + } + fn get_bond_id( + &mut self, + a: core::ffi::c_longlong, + b: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_molecule_get_bond_id( + sself: *mut core::ffi::c_void, + a: core::ffi::c_longlong, + b: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_molecule_get_bond_id(self.0, a, b) } + } + fn set_atomic_number_array_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_molecule_set_atomic_number_array_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_molecule_set_atomic_number_array_name(self.0, c__arg.as_ptr()) } + } + fn set_bond_orders_array_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_molecule_set_bond_orders_array_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_molecule_set_bond_orders_array_name(self.0, c__arg.as_ptr()) } + } +} +impl VtkMultiBlockDataSet for vtkMultiBlockDataSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_new_instance(self.0) } + } + fn set_number_of_blocks(&mut self, numBlocks: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_set_number_of_blocks( + sself: *mut core::ffi::c_void, + numBlocks: core::ffi::c_uint, + ); + } + unsafe { vtk_multi_block_data_set_set_number_of_blocks(self.0, numBlocks) } + } + fn get_number_of_blocks(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_number_of_blocks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_multi_block_data_set_get_number_of_blocks(self.0) } + } + fn get_block(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_block( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_get_block(self.0, blockno) } + } + fn set_block( + &mut self, + blockno: core::ffi::c_uint, + block: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_set_block( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + block: *mut core::ffi::c_void, + ); + } + unsafe { vtk_multi_block_data_set_set_block(self.0, blockno, block) } + } + fn remove_block(&mut self, blockno: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_remove_block( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + ); + } + unsafe { vtk_multi_block_data_set_remove_block(self.0, blockno) } + } + fn has_meta_data(&mut self, blockno: core::ffi::c_uint) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_multi_block_data_set_has_meta_data( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_multi_block_data_set_has_meta_data(self.0, blockno) } + } + fn get_meta_data(&mut self, blockno: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_meta_data( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_get_meta_data(self.0, blockno) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_get_data(self.0, info) } + } +} +impl VtkMultiPieceDataSet for vtkMultiPieceDataSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_new_instance(self.0) } + } + fn set_number_of_pieces(&mut self, numpieces: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_multi_piece_data_set_set_number_of_pieces( + sself: *mut core::ffi::c_void, + numpieces: core::ffi::c_uint, + ); + } + unsafe { vtk_multi_piece_data_set_set_number_of_pieces(self.0, numpieces) } + } + fn get_number_of_pieces(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_multi_piece_data_set_get_number_of_pieces(self.0) } + } + fn get_piece(&mut self, pieceno: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_piece( + sself: *mut core::ffi::c_void, + pieceno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_get_piece(self.0, pieceno) } + } + fn get_piece_as_data_object( + &mut self, + pieceno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_piece_as_data_object( + sself: *mut core::ffi::c_void, + pieceno: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_get_piece_as_data_object(self.0, pieceno) } + } + fn set_piece( + &mut self, + pieceno: core::ffi::c_uint, + piece: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_multi_piece_data_set_set_piece( + sself: *mut core::ffi::c_void, + pieceno: core::ffi::c_uint, + piece: *mut core::ffi::c_void, + ); + } + unsafe { vtk_multi_piece_data_set_set_piece(self.0, pieceno, piece) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_piece_data_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_piece_data_set_get_data(self.0, info) } + } +} +impl VtkMutableDirectedGraph for vtkMutableDirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_new_instance(self.0) } + } + fn set_number_of_vertices( + &mut self, + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_mutable_directed_graph_set_number_of_vertices( + sself: *mut core::ffi::c_void, + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_mutable_directed_graph_set_number_of_vertices(self.0, numVerts) } + } + fn add_vertex(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_mutable_directed_graph_add_vertex(self.0) } + } + fn lazy_add_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_vertex(sself: *mut core::ffi::c_void); + } + unsafe { vtk_mutable_directed_graph_lazy_add_vertex(self.0) } + } + fn lazy_add_edge( + &mut self, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + propertyArr: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + propertyArr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_lazy_add_edge(self.0, u, v, propertyArr) } + } + fn add_graph_edge( + &mut self, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_graph_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_directed_graph_add_graph_edge(self.0, u, v) } + } + fn add_child( + &mut self, + parent: core::ffi::c_longlong, + propertyArr: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_mutable_directed_graph_add_child( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_longlong, + propertyArr: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_mutable_directed_graph_add_child(self.0, parent, propertyArr) } + } + fn remove_vertex(&mut self, v: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_remove_vertex( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ); + } + unsafe { vtk_mutable_directed_graph_remove_vertex(self.0, v) } + } + fn remove_edge(&mut self, e: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_remove_edge( + sself: *mut core::ffi::c_void, + e: core::ffi::c_longlong, + ); + } + unsafe { vtk_mutable_directed_graph_remove_edge(self.0, e) } + } + fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_remove_vertices( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_remove_vertices(self.0, arr) } + } + fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_directed_graph_remove_edges( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_directed_graph_remove_edges(self.0, arr) } + } +} +impl VtkMutableUndirectedGraph for vtkMutableUndirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_new_instance(self.0) } + } + fn set_number_of_vertices( + &mut self, + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_set_number_of_vertices( + sself: *mut core::ffi::c_void, + numVerts: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_mutable_undirected_graph_set_number_of_vertices(self.0, numVerts) } + } + fn add_vertex(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_mutable_undirected_graph_add_vertex(self.0) } + } + fn lazy_add_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_vertex( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_vertex(self.0) } + } + fn lazy_add_edge( + &mut self, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_lazy_add_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ); + } + unsafe { vtk_mutable_undirected_graph_lazy_add_edge(self.0, u, v) } + } + fn add_graph_edge( + &mut self, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_add_graph_edge( + sself: *mut core::ffi::c_void, + u: core::ffi::c_longlong, + v: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_mutable_undirected_graph_add_graph_edge(self.0, u, v) } + } + fn remove_vertex(&mut self, v: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_remove_vertex( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ); + } + unsafe { vtk_mutable_undirected_graph_remove_vertex(self.0, v) } + } + fn remove_edge(&mut self, e: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_remove_edge( + sself: *mut core::ffi::c_void, + e: core::ffi::c_longlong, + ); + } + unsafe { vtk_mutable_undirected_graph_remove_edge(self.0, e) } + } + fn remove_vertices(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_remove_vertices( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_remove_vertices(self.0, arr) } + } + fn remove_edges(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_mutable_undirected_graph_remove_edges( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_mutable_undirected_graph_remove_edges(self.0, arr) } + } +} +impl VtkNonMergingPointLocator for vtkNonMergingPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_merging_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_merging_point_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_merging_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_merging_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_merging_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_merging_point_locator_new_instance(self.0) } + } + fn is_inserted_point( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_non_merging_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_non_merging_point_locator_is_inserted_point(self.0, p0, p1, p2) } + } +} +impl VtkNonOverlappingAMR for vtkNonOverlappingAMR { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_non_overlapping_amr_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_non_overlapping_amr_get_data_object_type(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_get_data(self.0, info) } + } +} +impl VtkOctreePointLocator for vtkOctreePointLocator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_new(self.0) } + } + fn set_maximum_points_per_region(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_set_maximum_points_per_region( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_octree_point_locator_set_maximum_points_per_region(self.0, _arg) } + } + fn get_maximum_points_per_region(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_get_maximum_points_per_region( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_get_maximum_points_per_region(self.0) } + } + fn set_create_cubic_octants(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_set_create_cubic_octants( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_octree_point_locator_set_create_cubic_octants(self.0, _arg) } + } + fn get_create_cubic_octants(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_get_create_cubic_octants( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_get_create_cubic_octants(self.0) } + } + fn get_fudge_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_get_fudge_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_octree_point_locator_get_fudge_factor(self.0) } + } + fn set_fudge_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_set_fudge_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_octree_point_locator_set_fudge_factor(self.0, _arg) } + } + fn get_number_of_leaf_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_get_number_of_leaf_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_get_number_of_leaf_nodes(self.0) } + } + fn get_region_containing_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_get_region_containing_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_get_region_containing_point(self.0, x, y, z) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_octree_point_locator_build_locator(self.0) } + } + fn find_closest_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_octree_point_locator_find_closest_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + dist2: &mut core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_octree_point_locator_find_closest_point(self.0, x, y, z, dist2) } + } + fn get_points_in_region( + &mut self, + leafNodeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_get_points_in_region( + sself: *mut core::ffi::c_void, + leafNodeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_get_points_in_region(self.0, leafNodeId) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_free_search_structure(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_generate_representation(self.0, level, pd) } + } +} +impl VtkOctreePointLocatorNode for vtkOctreePointLocatorNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_node_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_node_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_node_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_node_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_node_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_node_new(self.0) } + } + fn set_number_of_points(&mut self, numberOfPoints: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_number_of_points( + sself: *mut core::ffi::c_void, + numberOfPoints: core::ffi::c_int, + ); + } + unsafe { + vtk_octree_point_locator_node_set_number_of_points(self.0, numberOfPoints) + } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_node_get_number_of_points(self.0) } + } + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { + vtk_octree_point_locator_node_set_bounds( + self.0, + xMin, + xMax, + yMin, + yMax, + zMin, + zMax, + ) + } + } + fn set_data_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_set_data_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { + vtk_octree_point_locator_node_set_data_bounds( + self.0, + xMin, + xMax, + yMin, + yMax, + zMin, + zMax, + ) + } + } + fn get_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_node_get_id(self.0) } + } + fn get_min_id(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_min_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_octree_point_locator_node_get_min_id(self.0) } + } + fn create_child_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_create_child_nodes( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_node_create_child_nodes(self.0) } + } + fn delete_child_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_octree_point_locator_node_delete_child_nodes( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_octree_point_locator_node_delete_child_nodes(self.0) } + } + fn get_child(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_child( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_octree_point_locator_node_get_child(self.0, i) } + } + fn intersects_region( + &mut self, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_intersects_region( + sself: *mut core::ffi::c_void, + pi: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_octree_point_locator_node_intersects_region(self.0, pi, useDataBounds) + } + } + fn contains_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_octree_point_locator_node_contains_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_octree_point_locator_node_contains_point(self.0, x, y, z, useDataBounds) + } + } + fn get_distance_2_to_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_distance_2_to_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + useDataBounds: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { + vtk_octree_point_locator_node_get_distance_2_to_boundary( + self.0, + x, + y, + z, + top, + useDataBounds, + ) + } + } + fn get_distance_2_to_inner_boundary( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_octree_point_locator_node_get_distance_2_to_inner_boundary( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + top: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_octree_point_locator_node_get_distance_2_to_inner_boundary( + self.0, + x, + y, + z, + top, + ) + } + } +} +impl VtkOrderedTriangulator for vtkOrderedTriangulator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ordered_triangulator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ordered_triangulator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ordered_triangulator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ordered_triangulator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ordered_triangulator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ordered_triangulator_new(self.0) } + } + fn init_triangulation( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + numPts: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_init_triangulation( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + numPts: core::ffi::c_int, + ); + } + unsafe { + vtk_ordered_triangulator_init_triangulation( + self.0, + xmin, + xmax, + ymin, + ymax, + zmin, + zmax, + numPts, + ) + } + } + fn triangulate(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_triangulate(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_triangulate(self.0) } + } + fn template_triangulate( + &mut self, + cellType: core::ffi::c_int, + numPts: core::ffi::c_int, + numEdges: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_template_triangulate( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + numPts: core::ffi::c_int, + numEdges: core::ffi::c_int, + ); + } + unsafe { + vtk_ordered_triangulator_template_triangulate( + self.0, + cellType, + numPts, + numEdges, + ) + } + } + fn update_point_type( + &mut self, + internalId: core::ffi::c_longlong, + type_: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_update_point_type( + sself: *mut core::ffi::c_void, + internalId: core::ffi::c_longlong, + type_: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_update_point_type(self.0, internalId, type_) } + } + fn get_point_id( + &mut self, + internalId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_point_id( + sself: *mut core::ffi::c_void, + internalId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_ordered_triangulator_get_point_id(self.0, internalId) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ordered_triangulator_get_number_of_points(self.0) } + } + fn set_use_templates(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_set_use_templates( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_set_use_templates(self.0, _arg) } + } + fn get_use_templates(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_use_templates( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ordered_triangulator_get_use_templates(self.0) } + } + fn use_templates_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_use_templates_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_use_templates_on(self.0) } + } + fn use_templates_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_use_templates_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_use_templates_off(self.0) } + } + fn set_pre_sorted(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_set_pre_sorted( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_set_pre_sorted(self.0, _arg) } + } + fn get_pre_sorted(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_pre_sorted( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ordered_triangulator_get_pre_sorted(self.0) } + } + fn pre_sorted_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_pre_sorted_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_pre_sorted_on(self.0) } + } + fn pre_sorted_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_pre_sorted_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ordered_triangulator_pre_sorted_off(self.0) } + } + fn set_use_two_sort_ids(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_set_use_two_sort_ids( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ordered_triangulator_set_use_two_sort_ids(self.0, _arg) } + } + fn get_use_two_sort_ids(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_use_two_sort_ids( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ordered_triangulator_get_use_two_sort_ids(self.0) } + } + fn use_two_sort_ids_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_use_two_sort_ids_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ordered_triangulator_use_two_sort_ids_on(self.0) } + } + fn use_two_sort_ids_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_use_two_sort_ids_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ordered_triangulator_use_two_sort_ids_off(self.0) } + } + fn get_tetras( + &mut self, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_tetras( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_ordered_triangulator_get_tetras(self.0, classification, ugrid) } + } + fn add_tetras( + &mut self, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_ordered_triangulator_add_tetras( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + ugrid: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_ordered_triangulator_add_tetras(self.0, classification, ugrid) } + } + fn add_triangles( + &mut self, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_ordered_triangulator_add_triangles( + sself: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_ordered_triangulator_add_triangles(self.0, connectivity) } + } + fn init_tetra_traversal(&mut self) -> () { + unsafe extern "C" { + fn vtk_ordered_triangulator_init_tetra_traversal( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ordered_triangulator_init_tetra_traversal(self.0) } + } + fn get_next_tetra( + &mut self, + classification: core::ffi::c_int, + tet: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + tetScalars: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ordered_triangulator_get_next_tetra( + sself: *mut core::ffi::c_void, + classification: core::ffi::c_int, + tet: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + tetScalars: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_ordered_triangulator_get_next_tetra( + self.0, + classification, + tet, + cellScalars, + tetScalars, + ) + } + } +} +impl VtkOutEdgeIterator for vtkOutEdgeIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_new_instance(self.0) } + } + fn initialize(&mut self, g: *mut core::ffi::c_void, v: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_out_edge_iterator_initialize( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ); + } + unsafe { vtk_out_edge_iterator_initialize(self.0, g, v) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_get_graph(self.0) } + } + fn get_vertex(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_out_edge_iterator_get_vertex( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_out_edge_iterator_get_vertex(self.0) } + } + fn next_graph_edge(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_out_edge_iterator_next_graph_edge( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_out_edge_iterator_next_graph_edge(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_out_edge_iterator_has_next(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_out_edge_iterator_has_next(self.0) } + } +} +impl VtkOverlappingAMR for vtkOverlappingAMR { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_new_instance(self.0) } + } + fn number_of_blanked_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_number_of_blanked_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_number_of_blanked_points(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_get_data(self.0, info) } + } + fn set_refinement_ratio( + &mut self, + level: core::ffi::c_uint, + refRatio: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_refinement_ratio( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + refRatio: core::ffi::c_int, + ); + } + unsafe { vtk_overlapping_amr_set_refinement_ratio(self.0, level, refRatio) } + } + fn get_refinement_ratio(&mut self, level: core::ffi::c_uint) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_overlapping_amr_get_refinement_ratio( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_overlapping_amr_get_refinement_ratio(self.0, level) } + } + fn set_amr_block_source_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + sourceId: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_amr_block_source_index( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + sourceId: core::ffi::c_int, + ); + } + unsafe { + vtk_overlapping_amr_set_amr_block_source_index(self.0, level, id, sourceId) + } + } + fn get_amr_block_source_index( + &mut self, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_overlapping_amr_get_amr_block_source_index( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + id: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_overlapping_amr_get_amr_block_source_index(self.0, level, id) } + } + fn has_children_information(&mut self) -> bool { + unsafe extern "C" { + fn vtk_overlapping_amr_has_children_information( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_overlapping_amr_has_children_information(self.0) } + } + fn generate_parent_child_information(&mut self) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_generate_parent_child_information( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_overlapping_amr_generate_parent_child_information(self.0) } + } + fn print_parent_child_info( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_print_parent_child_info( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ); + } + unsafe { vtk_overlapping_amr_print_parent_child_info(self.0, level, index) } + } + fn get_amr_info(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_get_amr_info( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_get_amr_info(self.0) } + } + fn set_amr_info(&mut self, info: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_set_amr_info( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ); + } + unsafe { vtk_overlapping_amr_set_amr_info(self.0, info) } + } + fn audit(&mut self) -> () { + unsafe extern "C" { + fn vtk_overlapping_amr_audit(sself: *mut core::ffi::c_void); + } + unsafe { vtk_overlapping_amr_audit(self.0) } + } +} +impl VtkPartitionedDataSet for vtkPartitionedDataSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_new_instance(self.0) } + } + fn set_number_of_partitions(&mut self, numPartitions: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_set_number_of_partitions( + sself: *mut core::ffi::c_void, + numPartitions: core::ffi::c_uint, + ); + } + unsafe { + vtk_partitioned_data_set_set_number_of_partitions(self.0, numPartitions) + } + } + fn get_number_of_partitions(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_number_of_partitions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_partitioned_data_set_get_number_of_partitions(self.0) } + } + fn get_partition(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_partition( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_partition(self.0, idx) } + } + fn get_partition_as_data_object( + &mut self, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_partition_as_data_object( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_partition_as_data_object(self.0, idx) } + } + fn set_partition( + &mut self, + idx: core::ffi::c_uint, + partition: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_set_partition( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_set_partition(self.0, idx, partition) } + } + fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_has_meta_data( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_partitioned_data_set_has_meta_data(self.0, idx) } + } + fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_meta_data( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_meta_data(self.0, idx) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_get_data(self.0, info) } + } + fn remove_null_partitions(&mut self) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_remove_null_partitions( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_remove_null_partitions(self.0) } + } +} +impl VtkPartitionedDataSetCollection for vtkPartitionedDataSetCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_new_instance(self.0) } + } + fn set_number_of_partitioned_data_sets( + &mut self, + numDataSets: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets( + sself: *mut core::ffi::c_void, + numDataSets: core::ffi::c_uint, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_number_of_partitioned_data_sets( + self.0, + numDataSets, + ) + } + } + fn get_number_of_partitioned_data_sets(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { + vtk_partitioned_data_set_collection_get_number_of_partitioned_data_sets( + self.0, + ) + } + } + fn get_partitioned_data_set( + &mut self, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_partitioned_data_set( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_partitioned_data_set_collection_get_partitioned_data_set(self.0, idx) + } + } + fn set_partitioned_data_set( + &mut self, + idx: core::ffi::c_uint, + dataset: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_partitioned_data_set( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + dataset: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_partitioned_data_set( + self.0, + idx, + dataset, + ) + } + } + fn remove_partitioned_data_set(&mut self, idx: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_remove_partitioned_data_set( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ); + } + unsafe { + vtk_partitioned_data_set_collection_remove_partitioned_data_set(self.0, idx) + } + } + fn set_partition( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + object: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_partition( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + object: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_partition( + self.0, + idx, + partition, + object, + ) + } + } + fn get_partition( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_partition( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_partitioned_data_set_collection_get_partition(self.0, idx, partition) + } + } + fn get_partition_as_data_object( + &mut self, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_partition_as_data_object( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + partition: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_partitioned_data_set_collection_get_partition_as_data_object( + self.0, + idx, + partition, + ) + } + } + fn get_number_of_partitions(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_number_of_partitions( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { + vtk_partitioned_data_set_collection_get_number_of_partitions(self.0, idx) + } + } + fn set_number_of_partitions( + &mut self, + idx: core::ffi::c_uint, + numPartitions: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_number_of_partitions( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + numPartitions: core::ffi::c_uint, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_number_of_partitions( + self.0, + idx, + numPartitions, + ) + } + } + fn has_meta_data(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_has_meta_data( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_partitioned_data_set_collection_has_meta_data(self.0, idx) } + } + fn get_meta_data(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_meta_data( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_get_meta_data(self.0, idx) } + } + fn get_data_assembly(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_data_assembly( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_get_data_assembly(self.0) } + } + fn set_data_assembly(&mut self, assembly: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_set_data_assembly( + sself: *mut core::ffi::c_void, + assembly: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_partitioned_data_set_collection_set_data_assembly(self.0, assembly) + } + } + fn get_composite_index(&mut self, idx: core::ffi::c_uint) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_composite_index( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { vtk_partitioned_data_set_collection_get_composite_index(self.0, idx) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_get_data(self.0, info) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_partitioned_data_set_collection_get_m_time(self.0) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_collection_shallow_copy(self.0, src) } + } +} +impl VtkPath for vtkPath { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_path_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_path_get_data_object_type(self.0) } + } + fn insert_next_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + code: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_path_insert_next_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + code: core::ffi::c_int, + ); + } + unsafe { vtk_path_insert_next_point(self.0, x, y, z, code) } + } + fn set_codes(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_path_set_codes( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_path_set_codes(self.0, p0) } + } + fn get_codes(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_get_codes( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_get_codes(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_path_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_path_get_number_of_cells(self.0) } + } + fn get_cell(&mut self, p0: core::ffi::c_longlong, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_path_get_cell( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_path_get_cell(self.0, p0, p1) } + } + fn get_cell_points( + &mut self, + p0: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_path_get_cell_points( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_path_get_cell_points(self.0, p0, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_path_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_path_get_point_cells(self.0, ptId, cellIds) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_path_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_path_get_max_cell_size(self.0) } + } + fn allocate( + &mut self, + size: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_path_allocate( + sself: *mut core::ffi::c_void, + size: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ); + } + unsafe { vtk_path_allocate(self.0, size, extSize) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_path_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_path_reset(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_path_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_path_get_data(self.0, info) } + } +} +impl VtkPentagonalPrism for vtkPentagonalPrism { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pentagonal_prism_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pentagonal_prism_get_face(self.0, faceId) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pentagonal_prism_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pentagonal_prism_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkPerlinNoise for vtkPerlinNoise { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perlin_noise_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perlin_noise_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perlin_noise_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perlin_noise_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perlin_noise_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perlin_noise_new(self.0) } + } + fn set_frequency( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_set_frequency( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_set_frequency(self.0, _arg1, _arg2, _arg3) } + } + fn set_phase( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_set_phase( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_set_phase(self.0, _arg1, _arg2, _arg3) } + } + fn set_amplitude(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perlin_noise_set_amplitude( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_perlin_noise_set_amplitude(self.0, _arg) } + } + fn get_amplitude(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_perlin_noise_get_amplitude( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_perlin_noise_get_amplitude(self.0) } + } +} +impl VtkPiecewiseFunction for vtkPiecewiseFunction { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_new_instance(self.0) } + } + fn deep_copy(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_deep_copy( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_deep_copy(self.0, f) } + } + fn shallow_copy(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shallow_copy( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_shallow_copy(self.0, f) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_data_object_type(self.0) } + } + fn get_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_size(self.0) } + } + fn add_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_add_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_add_point(self.0, x, y) } + } + fn remove_point_by_index(&mut self, id: usize) -> bool { + unsafe extern "C" { + fn vtk_piecewise_function_remove_point_by_index( + sself: *mut core::ffi::c_void, + id: usize, + ) -> bool; + } + unsafe { vtk_piecewise_function_remove_point_by_index(self.0, id) } + } + fn remove_point(&mut self, x: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_remove_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_remove_point(self.0, x) } + } + fn remove_all_points(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_remove_all_points(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_remove_all_points(self.0) } + } + fn add_segment( + &mut self, + x1: core::ffi::c_double, + y1: core::ffi::c_double, + x2: core::ffi::c_double, + y2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_add_segment( + sself: *mut core::ffi::c_void, + x1: core::ffi::c_double, + y1: core::ffi::c_double, + x2: core::ffi::c_double, + y2: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_add_segment(self.0, x1, y1, x2, y2) } + } + fn get_value(&mut self, x: core::ffi::c_double) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_get_value( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_get_value(self.0, x) } + } + fn set_clamping(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_set_clamping( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_piecewise_function_set_clamping(self.0, _arg) } + } + fn get_clamping(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_clamping( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_clamping(self.0) } + } + fn clamping_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_clamping_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_clamping_on(self.0) } + } + fn clamping_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_clamping_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_clamping_off(self.0) } + } + fn set_use_log_scale(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_set_use_log_scale( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_piecewise_function_set_use_log_scale(self.0, _arg) } + } + fn get_use_log_scale(&mut self) -> bool { + unsafe extern "C" { + fn vtk_piecewise_function_get_use_log_scale( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_piecewise_function_get_use_log_scale(self.0) } + } + fn use_log_scale_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_use_log_scale_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_use_log_scale_on(self.0) } + } + fn use_log_scale_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_use_log_scale_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_use_log_scale_off(self.0) } + } + fn get_type(&mut self) -> &str { + unsafe extern "C" { + fn vtk_piecewise_function_get_type( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_piecewise_function_get_type(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_first_non_zero_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_get_first_non_zero_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_get_first_non_zero_value(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_piecewise_function_initialize(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_get_data(self.0, info) } + } + fn set_allow_duplicate_scalars(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_set_allow_duplicate_scalars( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_piecewise_function_set_allow_duplicate_scalars(self.0, _arg) } + } + fn get_allow_duplicate_scalars(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_get_allow_duplicate_scalars( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_get_allow_duplicate_scalars(self.0) } + } + fn allow_duplicate_scalars_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_allow_duplicate_scalars_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_allow_duplicate_scalars_on(self.0) } + } + fn allow_duplicate_scalars_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_allow_duplicate_scalars_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_allow_duplicate_scalars_off(self.0) } + } + fn estimate_min_number_of_samples( + &mut self, + x1: &core::ffi::c_double, + x2: &core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_piecewise_function_estimate_min_number_of_samples( + sself: *mut core::ffi::c_void, + x1: &core::ffi::c_double, + x2: &core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_piecewise_function_estimate_min_number_of_samples(self.0, x1, x2) } + } +} +impl VtkPixel for vtkPixel { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pixel_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pixel_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_pixel_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_pixel_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_pixel_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_inflate( + sself: *mut core::ffi::c_void, + dist: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_inflate(self.0, dist) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pixel_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pixel_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkPlane for vtkPlane { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_new_instance(self.0) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_plane_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_set_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_plane_set_origin(self.0, _arg1, _arg2, _arg3) } + } + fn push(&mut self, distance: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_plane_push( + sself: *mut core::ffi::c_void, + distance: core::ffi::c_double, + ); + } + unsafe { vtk_plane_push(self.0, distance) } + } +} +impl VtkPlaneCollection for vtkPlaneCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_plane_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_plane_collection_add_item(self.0, p0) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_get_next_item(self.0) } + } + fn get_item(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_collection_get_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_collection_get_item(self.0, i) } + } + fn get_number_of_items(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_collection_get_number_of_items( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_collection_get_number_of_items(self.0) } + } +} +impl VtkPlanes for vtkPlanes { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_new_instance(self.0) } + } + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_planes_set_points( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_planes_set_points(self.0, p0) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_get_points(self.0) } + } + fn set_normals(&mut self, normals: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_planes_set_normals( + sself: *mut core::ffi::c_void, + normals: *mut core::ffi::c_void, + ); + } + unsafe { vtk_planes_set_normals(self.0, normals) } + } + fn get_normals(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_get_normals( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_get_normals(self.0) } + } + fn set_bounds( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_planes_set_bounds( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + zmin: core::ffi::c_double, + zmax: core::ffi::c_double, + ); + } + unsafe { vtk_planes_set_bounds(self.0, xmin, xmax, ymin, ymax, zmin, zmax) } + } + fn get_number_of_planes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_get_number_of_planes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_get_number_of_planes(self.0) } + } + fn get_plane(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_get_plane( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_get_plane(self.0, i) } + } +} +impl VtkPlanesIntersection for vtkPlanesIntersection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_intersection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_intersection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_intersection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_intersection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_intersection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_intersection_new(self.0) } + } + fn set_region_vertices(&mut self, pts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_planes_intersection_set_region_vertices( + sself: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_planes_intersection_set_region_vertices(self.0, pts) } + } + fn get_number_of_region_vertices(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_intersection_get_number_of_region_vertices( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_intersection_get_number_of_region_vertices(self.0) } + } + fn get_num_region_vertices(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_intersection_get_num_region_vertices( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_intersection_get_num_region_vertices(self.0) } + } + fn intersects_region(&mut self, R: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_planes_intersection_intersects_region( + sself: *mut core::ffi::c_void, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_planes_intersection_intersects_region(self.0, R) } + } + fn convert_3_d_cell( + &mut self, + cell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_planes_intersection_convert_3_d_cell( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_planes_intersection_convert_3_d_cell(self.0, cell) } + } +} +impl VtkPointData for vtkPointData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_data_new_instance(self.0) } + } + fn null_point(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_point_data_null_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_point_data_null_point(self.0, ptId) } + } +} +impl VtkPointLocator for vtkPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_new_instance(self.0) } + } + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ); + } + unsafe { vtk_point_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } + } + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_point_locator_set_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_point_locator_set_number_of_points_per_bucket(self.0, _arg) } + } + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_get_number_of_points_per_bucket_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_locator_get_number_of_points_per_bucket_min_value(self.0) } + } + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_get_number_of_points_per_bucket_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_locator_get_number_of_points_per_bucket_max_value(self.0) } + } + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_locator_get_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_locator_get_number_of_points_per_bucket(self.0) } + } + fn is_inserted_point( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_locator_is_inserted_point( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_locator_is_inserted_point(self.0, x, y, z) } + } + fn find_distributed_points( + &mut self, + N: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_find_distributed_points( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + result: *mut core::ffi::c_void, + M: core::ffi::c_int, + ); + } + unsafe { + vtk_point_locator_find_distributed_points(self.0, N, x, y, z, result, M) + } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_locator_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_locator_get_points(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_locator_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_locator_initialize(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_locator_free_search_structure(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_locator_build_locator(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_locator_generate_representation(self.0, level, pd) } + } +} +impl VtkPointSet for vtkPointSet { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_new_instance(self.0) } + } + fn set_editable(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_point_set_set_editable(sself: *mut core::ffi::c_void, _arg: bool); + } + unsafe { vtk_point_set_set_editable(self.0, _arg) } + } + fn get_editable(&mut self) -> bool { + unsafe extern "C" { + fn vtk_point_set_get_editable(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_point_set_get_editable(self.0) } + } + fn editable_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_editable_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_editable_on(self.0) } + } + fn editable_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_editable_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_editable_off(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_initialize(self.0) } + } + fn copy_structure(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_copy_structure( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_copy_structure(self.0, pd) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_set_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_set_get_number_of_points(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_set_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_set_get_number_of_cells(self.0) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_set_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_set_get_max_cell_size(self.0) } + } + fn get_cell(&mut self, p0: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_cell( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_cell(self.0, p0) } + } + fn get_cell_points( + &mut self, + p0: core::ffi::c_longlong, + idList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_set_get_cell_points( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + idList: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_get_cell_points(self.0, p0, idList) } + } + fn get_point_cells( + &mut self, + p0: core::ffi::c_longlong, + idList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_point_set_get_point_cells( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + idList: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_get_point_cells(self.0, p0, idList) } + } + fn get_cell_type(&mut self, p0: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_set_get_cell_type( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_set_get_cell_type(self.0, p0) } + } + fn build_point_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_build_point_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_build_point_locator(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_build_locator(self.0) } + } + fn build_cell_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_build_cell_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_build_cell_locator(self.0) } + } + fn set_point_locator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_set_point_locator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_set_point_locator(self.0, p0) } + } + fn get_point_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_point_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_point_locator(self.0) } + } + fn set_cell_locator(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_set_cell_locator( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_set_cell_locator(self.0, p0) } + } + fn get_cell_locator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_cell_locator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_cell_locator(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_point_set_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_point_set_get_m_time(self.0) } + } + fn compute_bounds(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_compute_bounds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_compute_bounds(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_set_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_set_squeeze(self.0) } + } + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_set_points( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_set_points(self.0, p0) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_points(self.0) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_register(self.0, o) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_get_data(self.0, info) } + } +} +impl VtkPointSetCellIterator for vtkPointSetCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_cell_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_cell_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_cell_iterator_new_instance(self.0) } + } + fn is_done_with_traversal(&mut self) -> bool { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_point_set_cell_iterator_is_done_with_traversal(self.0) } + } + fn get_cell_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_set_cell_iterator_get_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_set_cell_iterator_get_cell_id(self.0) } + } +} +impl VtkPointsProjectedHull for vtkPointsProjectedHull { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_projected_hull_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_projected_hull_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_projected_hull_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_projected_hull_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_points_projected_hull_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_points_projected_hull_new(self.0) } + } + fn rectangle_intersection_x( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_x( + sself: *mut core::ffi::c_void, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_rectangle_intersection_x(self.0, R) } + } + fn rectangle_intersection_y( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_y( + sself: *mut core::ffi::c_void, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_rectangle_intersection_y(self.0, R) } + } + fn rectangle_intersection_z( + &mut self, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_rectangle_intersection_z( + sself: *mut core::ffi::c_void, + R: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_rectangle_intersection_z(self.0, R) } + } + fn get_size_ccw_hull_x(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_size_ccw_hull_x( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_size_ccw_hull_x(self.0) } + } + fn get_size_ccw_hull_y(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_size_ccw_hull_y( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_size_ccw_hull_y(self.0) } + } + fn get_size_ccw_hull_z(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_points_projected_hull_get_size_ccw_hull_z( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_points_projected_hull_get_size_ccw_hull_z(self.0) } + } + fn update(&mut self) -> () { + unsafe extern "C" { + fn vtk_points_projected_hull_update(sself: *mut core::ffi::c_void); + } + unsafe { vtk_points_projected_hull_update(self.0) } + } +} +impl VtkPolyData for vtkPolyData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_data_object_type(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_copy_structure(self.0, ds) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_data_get_number_of_cells(self.0) } + } + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_cell(self.0, cellId) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_cell_type(self.0, cellId) } + } + fn copy_cells( + &mut self, + pd: *mut core::ffi::c_void, + idList: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_copy_cells( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + idList: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_copy_cells(self.0, pd, idList, locator) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_get_point_cells(self.0, ptId, cellIds) } + } + fn compute_cells_bounds(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_compute_cells_bounds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_compute_cells_bounds(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_squeeze(self.0) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_max_cell_size(self.0) } + } + fn get_cell_id_relative_to_cell_array( + &mut self, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_data_get_cell_id_relative_to_cell_array( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_data_get_cell_id_relative_to_cell_array(self.0, cellId) } + } + fn set_verts(&mut self, v: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_set_verts( + sself: *mut core::ffi::c_void, + v: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_set_verts(self.0, v) } + } + fn get_verts(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_verts( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_verts(self.0) } + } + fn set_lines(&mut self, l: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_set_lines( + sself: *mut core::ffi::c_void, + l: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_set_lines(self.0, l) } + } + fn get_lines(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_lines( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_lines(self.0) } + } + fn set_polys(&mut self, p: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_set_polys( + sself: *mut core::ffi::c_void, + p: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_set_polys(self.0, p) } + } + fn get_polys(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_polys( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_polys(self.0) } + } + fn set_strips(&mut self, s: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_set_strips( + sself: *mut core::ffi::c_void, + s: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_set_strips(self.0, s) } + } + fn get_strips(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_strips( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_strips(self.0) } + } + fn get_number_of_verts(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_verts( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_data_get_number_of_verts(self.0) } + } + fn get_number_of_lines(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_lines( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_data_get_number_of_lines(self.0) } + } + fn get_number_of_polys(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_polys( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_data_get_number_of_polys(self.0) } + } + fn get_number_of_strips(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_strips( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_data_get_number_of_strips(self.0) } + } + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_estimate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_poly_data_allocate_estimate(self.0, numCells, maxCellSize) } + } + fn allocate_exact( + &mut self, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_exact( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_poly_data_allocate_exact(self.0, numCells, connectivitySize) } + } + fn allocate_copy(&mut self, pd: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_copy( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_poly_data_allocate_copy(self.0, pd) } + } + fn allocate_proportional( + &mut self, + pd: *mut core::ffi::c_void, + ratio: core::ffi::c_double, + ) -> bool { + unsafe extern "C" { + fn vtk_poly_data_allocate_proportional( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ratio: core::ffi::c_double, + ) -> bool; + } + unsafe { vtk_poly_data_allocate_proportional(self.0, pd, ratio) } + } + fn allocate( + &mut self, + numCells: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_allocate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ); + } + unsafe { vtk_poly_data_allocate(self.0, numCells, extSize) } + } + fn insert_next_cell( + &mut self, + type_: core::ffi::c_int, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_data_insert_next_cell( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_data_insert_next_cell(self.0, type_, pts) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_reset(self.0) } + } + fn build_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_build_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_build_cells(self.0) } + } + fn need_to_build_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_poly_data_need_to_build_cells(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_poly_data_need_to_build_cells(self.0) } + } + fn build_links(&mut self, initialSize: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_poly_data_build_links( + sself: *mut core::ffi::c_void, + initialSize: core::ffi::c_int, + ); + } + unsafe { vtk_poly_data_build_links(self.0, initialSize) } + } + fn delete_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_delete_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_delete_cells(self.0) } + } + fn delete_links(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_delete_links(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_delete_links(self.0) } + } + fn get_cell_edge_neighbors( + &mut self, + cellId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_get_cell_edge_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_get_cell_edge_neighbors(self.0, cellId, p1, p2, cellIds) } + } + fn is_triangle( + &mut self, + v1: core::ffi::c_int, + v2: core::ffi::c_int, + v3: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_is_triangle( + sself: *mut core::ffi::c_void, + v1: core::ffi::c_int, + v2: core::ffi::c_int, + v3: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_is_triangle(self.0, v1, v2, v3) } + } + fn is_edge( + &mut self, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_is_edge( + sself: *mut core::ffi::c_void, + p1: core::ffi::c_longlong, + p2: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_is_edge(self.0, p1, p2) } + } + fn is_point_used_by_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_is_point_used_by_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_is_point_used_by_cell(self.0, ptId, cellId) } + } + fn replace_cell( + &mut self, + cellId: core::ffi::c_longlong, + ids: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_replace_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ids: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_replace_cell(self.0, cellId, ids) } + } + fn replace_cell_point( + &mut self, + cellId: core::ffi::c_longlong, + oldPtId: core::ffi::c_longlong, + newPtId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_replace_cell_point( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + oldPtId: core::ffi::c_longlong, + newPtId: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_data_replace_cell_point(self.0, cellId, oldPtId, newPtId) } + } + fn reverse_cell(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_data_reverse_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_data_reverse_cell(self.0, cellId) } + } + fn delete_point(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_data_delete_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_data_delete_point(self.0, ptId) } + } + fn delete_cell(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_data_delete_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_data_delete_cell(self.0, cellId) } + } + fn remove_deleted_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_remove_deleted_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_remove_deleted_cells(self.0) } + } + fn insert_next_linked_point( + &mut self, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_data_insert_next_linked_point( + sself: *mut core::ffi::c_void, + numLinks: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_data_insert_next_linked_point(self.0, numLinks) } + } + fn remove_cell_reference(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_data_remove_cell_reference( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_data_remove_cell_reference(self.0, cellId) } + } + fn add_cell_reference(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_data_add_cell_reference( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_data_add_cell_reference(self.0, cellId) } + } + fn remove_reference_to_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_remove_reference_to_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_data_remove_reference_to_cell(self.0, ptId, cellId) } + } + fn add_reference_to_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_add_reference_to_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_data_add_reference_to_cell(self.0, ptId, cellId) } + } + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_data_resize_cell_list( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ); + } + unsafe { vtk_poly_data_resize_cell_list(self.0, ptId, size) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_initialize(self.0) } + } + fn get_piece(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_piece( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_piece(self.0) } + } + fn get_number_of_pieces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_number_of_pieces(self.0) } + } + fn get_ghost_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_ghost_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_data_get_ghost_level(self.0) } + } + fn remove_ghost_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_data_remove_ghost_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_data_remove_ghost_cells(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_get_data(self.0, info) } + } + fn get_scalar_field_critical_index( + &mut self, + pointId: core::ffi::c_longlong, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_data_get_scalar_field_critical_index( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_longlong, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_poly_data_get_scalar_field_critical_index(self.0, pointId, scalarField) + } + } + fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_poly_data_get_mesh_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_poly_data_get_mesh_m_time(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_poly_data_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_poly_data_get_m_time(self.0) } + } +} +impl VtkPolyDataCollection for vtkPolyDataCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_new_instance(self.0) } + } + fn add_item(&mut self, pd: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_collection_add_item( + sself: *mut core::ffi::c_void, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_collection_add_item(self.0, pd) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_collection_get_next_item(self.0) } + } +} +impl VtkPolyLine for vtkPolyLine { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_new_instance(self.0) } + } + fn generate_sliding_normals( + &mut self, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_generate_sliding_normals( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_generate_sliding_normals(self.0, p0, p1, p2) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_line_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_poly_line_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_line_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_poly_line_clip( + self.0, + value, + cellScalars, + locator, + lines, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkPolyPlane for vtkPolyPlane { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_plane_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_plane_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_plane_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_plane_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_plane_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_plane_new_instance(self.0) } + } + fn set_poly_line(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_plane_set_poly_line( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_plane_set_poly_line(self.0, p0) } + } + fn get_poly_line(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_plane_get_poly_line( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_plane_get_poly_line(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_poly_plane_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_poly_plane_get_m_time(self.0) } + } +} +impl VtkPolyVertex for vtkPolyVertex { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_vertex_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_vertex_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_poly_vertex_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_poly_vertex_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_poly_vertex_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_poly_vertex_clip( + self.0, + value, + cellScalars, + locator, + verts, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_vertex_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_vertex_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkPolygon for vtkPolygon { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polygon_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polygon_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_polygon_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_polygon_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tris: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_polygon_clip( + self.0, + value, + cellScalars, + locator, + tris, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_triangulate(self.0, index, ptIds, pts) } + } + fn compute_area(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_compute_area( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_compute_area(self.0) } + } + fn is_convex(&mut self) -> bool { + unsafe extern "C" { + fn vtk_polygon_is_convex(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_polygon_is_convex(self.0) } + } + fn non_degenerate_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_non_degenerate_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_non_degenerate_triangulate(self.0, outTris) } + } + fn bounded_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_bounded_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_bounded_triangulate(self.0, outTris, tol) } + } + fn get_use_mvc_interpolation(&mut self) -> bool { + unsafe extern "C" { + fn vtk_polygon_get_use_mvc_interpolation( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_polygon_get_use_mvc_interpolation(self.0) } + } + fn set_use_mvc_interpolation(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_polygon_set_use_mvc_interpolation( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_polygon_set_use_mvc_interpolation(self.0, _arg) } + } + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_polygon_set_tolerance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_polygon_set_tolerance(self.0, _arg) } + } + fn get_tolerance_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_get_tolerance_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_get_tolerance_min_value(self.0) } + } + fn get_tolerance_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_get_tolerance_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_get_tolerance_max_value(self.0) } + } + fn get_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polygon_get_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polygon_get_tolerance(self.0) } + } + fn ear_cut_triangulation(&mut self, measure: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_ear_cut_triangulation( + sself: *mut core::ffi::c_void, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_ear_cut_triangulation(self.0, measure) } + } + fn unbiased_ear_cut_triangulation( + &mut self, + seed: core::ffi::c_int, + measure: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polygon_unbiased_ear_cut_triangulation( + sself: *mut core::ffi::c_void, + seed: core::ffi::c_int, + measure: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_polygon_unbiased_ear_cut_triangulation(self.0, seed, measure) } + } +} +impl VtkPolyhedron for vtkPolyhedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_get_cell_type(self.0) } + } + fn requires_initialization(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_requires_initialization( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_requires_initialization(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_get_number_of_edges(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_get_edge(self.0, p0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_get_number_of_faces(self.0) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_polyhedron_contour( + self.0, + value, + scalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_polyhedron_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + scalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + connectivity: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_polyhedron_clip( + self.0, + value, + scalars, + locator, + connectivity, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_triangulate(self.0, index, ptIds, pts) } + } + fn is_primary_cell(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_is_primary_cell( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_is_primary_cell(self.0) } + } + fn requires_explicit_face_representation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_polyhedron_requires_explicit_face_representation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_polyhedron_requires_explicit_face_representation(self.0) } + } + fn is_convex(&mut self) -> bool { + unsafe extern "C" { + fn vtk_polyhedron_is_convex(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_polyhedron_is_convex(self.0) } + } + fn get_poly_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polyhedron_get_poly_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polyhedron_get_poly_data(self.0) } + } +} +impl VtkPyramid for vtkPyramid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pyramid_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pyramid_get_face(self.0, faceId) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_pyramid_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_pyramid_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkQuad for vtkQuad { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_cell_type(sself: *mut core::ffi::c_void) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quad_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quad_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quad_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quad_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quad_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quad_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quad_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quad_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticEdge for vtkQuadraticEdge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_edge_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_edge_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_edge_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_edge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_edge_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_edge_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_edge_clip( + self.0, + value, + cellScalars, + locator, + lines, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticHexahedron for vtkQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_hexahedron_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_hexahedron_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_hexahedron_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_hexahedron_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticLinearQuad for vtkQuadraticLinearQuad { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_quad_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_linear_quad_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_quad_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_quad_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_linear_quad_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticLinearWedge for vtkQuadraticLinearWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_linear_wedge_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_linear_wedge_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_linear_wedge_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_linear_wedge_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_linear_wedge_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticPolygon for vtkQuadraticPolygon { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_polygon_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_polygon_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_polygon_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate(&mut self, outTris: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_triangulate(self.0, outTris) } + } + fn non_degenerate_triangulate( + &mut self, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_polygon_non_degenerate_triangulate( + sself: *mut core::ffi::c_void, + outTris: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_polygon_non_degenerate_triangulate(self.0, outTris) } + } + fn get_use_mvc_interpolation(&mut self) -> bool { + unsafe extern "C" { + fn vtk_quadratic_polygon_get_use_mvc_interpolation( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_quadratic_polygon_get_use_mvc_interpolation(self.0) } + } + fn set_use_mvc_interpolation(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_quadratic_polygon_set_use_mvc_interpolation( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_quadratic_polygon_set_use_mvc_interpolation(self.0, _arg) } + } +} +impl VtkQuadraticPyramid for vtkQuadraticPyramid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_pyramid_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_pyramid_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_pyramid_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_pyramid_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_pyramid_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_pyramid_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_pyramid_clip( + self.0, + value, + cellScalars, + locator, + tets, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticQuad for vtkQuadraticQuad { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_quad_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_quad_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_quad_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_quad_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_quad_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_quad_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_quad_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticTetra for vtkQuadraticTetra { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_tetra_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_tetra_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_tetra_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_tetra_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_tetra_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_tetra_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_tetra_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticTriangle for vtkQuadraticTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_triangle_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_triangle_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_triangle_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_triangle_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_triangle_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_triangle_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_triangle_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadraticWedge for vtkQuadraticWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadratic_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadratic_wedge_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_quadratic_wedge_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadratic_wedge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadratic_wedge_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_quadratic_wedge_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_quadratic_wedge_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkQuadratureSchemeDefinition for vtkQuadratureSchemeDefinition { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_new_instance(self.0) } + } + fn dictionary(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_dictionary( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_dictionary(self.0) } + } + fn quadrature_offset_array_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_quadrature_offset_array_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_quadrature_offset_array_name(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadrature_scheme_definition_new(self.0) } + } + fn save_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_save_state( + sself: *mut core::ffi::c_void, + root: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_save_state(self.0, root) } + } + fn restore_state(&mut self, root: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_restore_state( + sself: *mut core::ffi::c_void, + root: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_restore_state(self.0, root) } + } + fn clear(&mut self) -> () { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_clear(sself: *mut core::ffi::c_void); + } + unsafe { vtk_quadrature_scheme_definition_clear(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_get_cell_type(self.0) } + } + fn get_quadrature_key(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_quadrature_key( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_get_quadrature_key(self.0) } + } + fn get_number_of_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_number_of_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quadrature_scheme_definition_get_number_of_nodes(self.0) } + } + fn get_number_of_quadrature_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quadrature_scheme_definition_get_number_of_quadrature_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_quadrature_scheme_definition_get_number_of_quadrature_points(self.0) + } + } +} +impl VtkQuadric for vtkQuadric { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadric_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quadric_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_quadric_new(self.0) } + } + fn set_coefficients( + &mut self, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + a4: core::ffi::c_double, + a5: core::ffi::c_double, + a6: core::ffi::c_double, + a7: core::ffi::c_double, + a8: core::ffi::c_double, + a9: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_quadric_set_coefficients( + sself: *mut core::ffi::c_void, + a0: core::ffi::c_double, + a1: core::ffi::c_double, + a2: core::ffi::c_double, + a3: core::ffi::c_double, + a4: core::ffi::c_double, + a5: core::ffi::c_double, + a6: core::ffi::c_double, + a7: core::ffi::c_double, + a8: core::ffi::c_double, + a9: core::ffi::c_double, + ); + } + unsafe { + vtk_quadric_set_coefficients(self.0, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) + } + } +} +impl VtkRectilinearGrid for vtkRectilinearGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_data_object_type(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_copy_structure(self.0, ds) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_rectilinear_grid_initialize(self.0) } + } + fn get_number_of_cells(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_number_of_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_rectilinear_grid_get_number_of_cells(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_rectilinear_grid_get_number_of_points(self.0) } + } + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_cell(self.0, cellId) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_cell_type(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_get_point_cells(self.0, ptId, cellIds) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_max_cell_size(self.0) } + } + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_is_point_visible( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_is_point_visible(self.0, ptId) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_rectilinear_grid_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_rectilinear_grid_is_cell_visible(self.0, cellId) } + } + fn has_any_blank_points(&mut self) -> bool { + unsafe extern "C" { + fn vtk_rectilinear_grid_has_any_blank_points( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_rectilinear_grid_has_any_blank_points(self.0) } + } + fn has_any_blank_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_rectilinear_grid_has_any_blank_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_rectilinear_grid_has_any_blank_cells(self.0) } + } + fn get_points(&mut self, pnts: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_points( + sself: *mut core::ffi::c_void, + pnts: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_get_points(self.0, pnts) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_rectilinear_grid_set_dimensions(self.0, i, j, k) } + } + fn get_data_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_data_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_data_dimension(self.0) } + } + fn set_x_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_x_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_set_x_coordinates(self.0, p0) } + } + fn get_x_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_x_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_x_coordinates(self.0) } + } + fn set_y_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_y_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_set_y_coordinates(self.0, p0) } + } + fn get_y_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_y_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_y_coordinates(self.0) } + } + fn set_z_coordinates(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_z_coordinates( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_set_z_coordinates(self.0, p0) } + } + fn get_z_coordinates(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_z_coordinates( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_z_coordinates(self.0) } + } + fn set_extent( + &mut self, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_extent( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ); + } + unsafe { + vtk_rectilinear_grid_set_extent(self.0, xMin, xMax, yMin, yMax, zMin, zMax) + } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_extent_type(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_get_data(self.0, info) } + } + fn set_scalar_type( + &mut self, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_scalar_type( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_set_scalar_type(self.0, p0, meta_data) } + } + fn get_scalar_type( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectilinear_grid_get_scalar_type(self.0, meta_data) } + } + fn has_scalar_type(&mut self, meta_data: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_rectilinear_grid_has_scalar_type( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_rectilinear_grid_has_scalar_type(self.0, meta_data) } + } + fn get_scalar_type_as_string(&mut self) -> &str { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_scalar_type_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_rectilinear_grid_get_scalar_type_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_number_of_scalar_components( + &mut self, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_set_number_of_scalar_components( + sself: *mut core::ffi::c_void, + n: core::ffi::c_int, + meta_data: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_rectilinear_grid_set_number_of_scalar_components(self.0, n, meta_data) + } + } + fn get_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectilinear_grid_get_number_of_scalar_components( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_rectilinear_grid_get_number_of_scalar_components(self.0, meta_data) + } + } + fn has_number_of_scalar_components( + &mut self, + meta_data: *mut core::ffi::c_void, + ) -> bool { + unsafe extern "C" { + fn vtk_rectilinear_grid_has_number_of_scalar_components( + sself: *mut core::ffi::c_void, + meta_data: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_rectilinear_grid_has_number_of_scalar_components(self.0, meta_data) + } + } +} +impl VtkReebGraph for vtkReebGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_new_instance(self.0) } + } + fn build( + &mut self, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_build( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + scalarField: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_reeb_graph_build(self.0, mesh, scalarField) } + } + fn stream_triangle( + &mut self, + vertex0Id: core::ffi::c_longlong, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_longlong, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_longlong, + scalar2: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_stream_triangle( + sself: *mut core::ffi::c_void, + vertex0Id: core::ffi::c_longlong, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_longlong, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_longlong, + scalar2: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_reeb_graph_stream_triangle( + self.0, + vertex0Id, + scalar0, + vertex1Id, + scalar1, + vertex2Id, + scalar2, + ) + } + } + fn stream_tetrahedron( + &mut self, + vertex0Id: core::ffi::c_longlong, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_longlong, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_longlong, + scalar2: core::ffi::c_double, + vertex3Id: core::ffi::c_longlong, + scalar3: core::ffi::c_double, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_stream_tetrahedron( + sself: *mut core::ffi::c_void, + vertex0Id: core::ffi::c_longlong, + scalar0: core::ffi::c_double, + vertex1Id: core::ffi::c_longlong, + scalar1: core::ffi::c_double, + vertex2Id: core::ffi::c_longlong, + scalar2: core::ffi::c_double, + vertex3Id: core::ffi::c_longlong, + scalar3: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { + vtk_reeb_graph_stream_tetrahedron( + self.0, + vertex0Id, + scalar0, + vertex1Id, + scalar1, + vertex2Id, + scalar2, + vertex3Id, + scalar3, + ) + } + } + fn close_stream(&mut self) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_close_stream(sself: *mut core::ffi::c_void); + } + unsafe { vtk_reeb_graph_close_stream(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_reeb_graph_deep_copy(self.0, src) } + } + fn simplify( + &mut self, + simplificationThreshold: core::ffi::c_double, + simplificationMetric: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_reeb_graph_simplify( + sself: *mut core::ffi::c_void, + simplificationThreshold: core::ffi::c_double, + simplificationMetric: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_reeb_graph_simplify( + self.0, + simplificationThreshold, + simplificationMetric, + ) + } + } + fn set(&mut self, g: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_set( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ); + } + unsafe { vtk_reeb_graph_set(self.0, g) } + } +} +impl VtkReebGraphSimplificationMetric for vtkReebGraphSimplificationMetric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_simplification_metric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_simplification_metric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reeb_graph_simplification_metric_new_instance(self.0) } + } + fn set_lower_bound(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_set_lower_bound( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_reeb_graph_simplification_metric_set_lower_bound(self.0, _arg) } + } + fn get_lower_bound(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_get_lower_bound( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_reeb_graph_simplification_metric_get_lower_bound(self.0) } + } + fn set_upper_bound(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_set_upper_bound( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_reeb_graph_simplification_metric_set_upper_bound(self.0, _arg) } + } + fn get_upper_bound(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_get_upper_bound( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_reeb_graph_simplification_metric_get_upper_bound(self.0) } + } + fn compute_metric( + &mut self, + mesh: *mut core::ffi::c_void, + field: *mut core::ffi::c_void, + startCriticalPoint: core::ffi::c_longlong, + vertexList: *mut core::ffi::c_void, + endCriticalPoint: core::ffi::c_longlong, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_reeb_graph_simplification_metric_compute_metric( + sself: *mut core::ffi::c_void, + mesh: *mut core::ffi::c_void, + field: *mut core::ffi::c_void, + startCriticalPoint: core::ffi::c_longlong, + vertexList: *mut core::ffi::c_void, + endCriticalPoint: core::ffi::c_longlong, + ) -> core::ffi::c_double; + } + unsafe { + vtk_reeb_graph_simplification_metric_compute_metric( + self.0, + mesh, + field, + startCriticalPoint, + vertexList, + endCriticalPoint, + ) + } + } +} +impl VtkSelection for vtkSelection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_new(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_get_data_object_type(self.0) } + } + fn get_number_of_nodes(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_selection_get_number_of_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_selection_get_number_of_nodes(self.0) } + } + fn get_node(&mut self, idx: core::ffi::c_uint) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_get_node( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_get_node(self.0, idx) } + } + fn set_node(&mut self, name: &str, p1: *mut core::ffi::c_void) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_set_node( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_set_node(self.0, c_name.as_ptr(), p1) } + } + fn remove_node(&mut self, idx: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_selection_remove_node( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_uint, + ); + } + unsafe { vtk_selection_remove_node(self.0, idx) } + } + fn remove_all_nodes(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_remove_all_nodes(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_remove_all_nodes(self.0) } + } + fn set_expression(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_set_expression( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_set_expression(self.0, c__arg.as_ptr()) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_deep_copy(self.0, src) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_shallow_copy(self.0, src) } + } + fn union(&mut self, selection: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_union( + sself: *mut core::ffi::c_void, + selection: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_union(self.0, selection) } + } + fn subtract(&mut self, selection: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_subtract( + sself: *mut core::ffi::c_void, + selection: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_subtract(self.0, selection) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_selection_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_selection_get_m_time(self.0) } + } + fn dump(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_dump(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_dump(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_get_data(self.0, info) } + } +} +impl VtkSelectionNode for vtkSelectionNode { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_new(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_node_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_node_initialize(self.0) } + } + fn set_selection_list(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_selection_list( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_set_selection_list(self.0, p0) } + } + fn get_selection_list(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_get_selection_list( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_get_selection_list(self.0) } + } + fn set_selection_data(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_selection_data( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_set_selection_data(self.0, data) } + } + fn get_selection_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_get_selection_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_get_selection_data(self.0) } + } + fn get_properties(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_get_properties( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_get_properties(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_deep_copy(self.0, src) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_shallow_copy(self.0, src) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_selection_node_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_selection_node_get_m_time(self.0) } + } + fn content_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_content_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_content_type(self.0) } + } + fn set_content_type(&mut self, type_: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_content_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ); + } + unsafe { vtk_selection_node_set_content_type(self.0, type_) } + } + fn get_content_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_get_content_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_node_get_content_type(self.0) } + } + fn get_content_type_as_string(&mut self, type_: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_selection_node_get_content_type_as_string( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { + vtk_selection_node_get_content_type_as_string(self.0, type_) + }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn field_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_field_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_field_type(self.0) } + } + fn set_field_type(&mut self, type_: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_node_set_field_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ); + } + unsafe { vtk_selection_node_set_field_type(self.0, type_) } + } + fn get_field_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_get_field_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_node_get_field_type(self.0) } + } + fn get_field_type_as_string(&mut self, type_: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_selection_node_get_field_type_as_string( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_selection_node_get_field_type_as_string(self.0, type_) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_field_type_from_string(&mut self, type_: &str) -> core::ffi::c_int { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_node_get_field_type_from_string( + sself: *mut core::ffi::c_void, + type_: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_node_get_field_type_from_string(self.0, c_type.as_ptr()) } + } + fn convert_selection_field_to_attribute_type( + &mut self, + val: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_convert_selection_field_to_attribute_type( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_selection_node_convert_selection_field_to_attribute_type(self.0, val) + } + } + fn convert_attribute_type_to_selection_field( + &mut self, + val: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_node_convert_attribute_type_to_selection_field( + sself: *mut core::ffi::c_void, + val: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_selection_node_convert_attribute_type_to_selection_field(self.0, val) + } + } + fn set_query_string(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_node_set_query_string( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_node_set_query_string(self.0, c__arg.as_ptr()) } + } + fn epsilon(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_epsilon( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_epsilon(self.0) } + } + fn zbuffer_value(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_zbuffer_value( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_zbuffer_value(self.0) } + } + fn containing_cells(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_containing_cells( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_containing_cells(self.0) } + } + fn connected_layers(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_connected_layers( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_connected_layers(self.0) } + } + fn component_number(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_component_number( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_component_number(self.0) } + } + fn inverse(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_inverse( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_inverse(self.0) } + } + fn pixel_count(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_pixel_count( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_pixel_count(self.0) } + } + fn source(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_source( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_source(self.0) } + } + fn source_id(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_source_id( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_source_id(self.0) } + } + fn prop(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_prop( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_prop(self.0) } + } + fn prop_id(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_prop_id( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_prop_id(self.0) } + } + fn process_id(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_process_id( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_process_id(self.0) } + } + fn assembly_name(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_assembly_name( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_assembly_name(self.0) } + } + fn selectors(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_selectors( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_selectors(self.0) } + } + fn composite_index(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_composite_index( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_composite_index(self.0) } + } + fn hierarchical_level(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_hierarchical_level( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_hierarchical_level(self.0) } + } + fn hierarchical_index(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_hierarchical_index( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_hierarchical_index(self.0) } + } + fn indexed_vertices(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_node_indexed_vertices( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_node_indexed_vertices(self.0) } + } + fn union_selection_list(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_union_selection_list( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_union_selection_list(self.0, other) } + } + fn subtract_selection_list(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_node_subtract_selection_list( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_node_subtract_selection_list(self.0, other) } + } + fn equal_properties( + &mut self, + other: *mut core::ffi::c_void, + fullcompare: bool, + ) -> bool { + unsafe extern "C" { + fn vtk_selection_node_equal_properties( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + fullcompare: bool, + ) -> bool; + } + unsafe { vtk_selection_node_equal_properties(self.0, other, fullcompare) } + } +} +impl VtkSimpleCellTessellator for vtkSimpleCellTessellator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_cell_tessellator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_cell_tessellator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_cell_tessellator_new_instance(self.0) } + } + fn get_generic_cell(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_get_generic_cell( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_cell_tessellator_get_generic_cell(self.0) } + } + fn tessellate_face( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_tessellate_face( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_simple_cell_tessellator_tessellate_face( + self.0, + cell, + att, + index, + points, + cellArray, + internalPd, + ) + } + } + fn tessellate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_tessellate( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_simple_cell_tessellator_tessellate( + self.0, + cell, + att, + points, + cellArray, + internalPd, + ) + } + } + fn triangulate( + &mut self, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_triangulate( + sself: *mut core::ffi::c_void, + cell: *mut core::ffi::c_void, + att: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + cellArray: *mut core::ffi::c_void, + internalPd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_simple_cell_tessellator_triangulate( + self.0, + cell, + att, + points, + cellArray, + internalPd, + ) + } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_simple_cell_tessellator_reset(self.0) } + } + fn initialize(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_initialize( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_simple_cell_tessellator_initialize(self.0, ds) } + } + fn get_fixed_subdivisions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_get_fixed_subdivisions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_cell_tessellator_get_fixed_subdivisions(self.0) } + } + fn get_max_subdivision_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_get_max_subdivision_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_cell_tessellator_get_max_subdivision_level(self.0) } + } + fn get_max_adaptive_subdivisions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_get_max_adaptive_subdivisions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_cell_tessellator_get_max_adaptive_subdivisions(self.0) } + } + fn set_fixed_subdivisions(&mut self, level: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_set_fixed_subdivisions( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + ); + } + unsafe { vtk_simple_cell_tessellator_set_fixed_subdivisions(self.0, level) } + } + fn set_max_subdivision_level(&mut self, level: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_set_max_subdivision_level( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + ); + } + unsafe { vtk_simple_cell_tessellator_set_max_subdivision_level(self.0, level) } + } + fn set_subdivision_levels( + &mut self, + fixed: core::ffi::c_int, + maxLevel: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_simple_cell_tessellator_set_subdivision_levels( + sself: *mut core::ffi::c_void, + fixed: core::ffi::c_int, + maxLevel: core::ffi::c_int, + ); + } + unsafe { + vtk_simple_cell_tessellator_set_subdivision_levels(self.0, fixed, maxLevel) + } + } +} +impl VtkSmoothErrorMetric for vtkSmoothErrorMetric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smooth_error_metric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smooth_error_metric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smooth_error_metric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smooth_error_metric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smooth_error_metric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smooth_error_metric_new_instance(self.0) } + } + fn get_angle_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_smooth_error_metric_get_angle_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_smooth_error_metric_get_angle_tolerance(self.0) } + } + fn set_angle_tolerance(&mut self, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_smooth_error_metric_set_angle_tolerance( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + ); + } + unsafe { vtk_smooth_error_metric_set_angle_tolerance(self.0, value) } + } +} +impl VtkSortFieldData for vtkSortFieldData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_field_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_field_data_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_field_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_field_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sort_field_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sort_field_data_new_instance(self.0) } + } +} +impl VtkSphere for vtkSphere { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_set_center(self.0, _arg1, _arg2, _arg3) } + } +} +impl VtkSpheres for vtkSpheres { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_new_instance(self.0) } + } + fn set_centers(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_spheres_set_centers( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_spheres_set_centers(self.0, p0) } + } + fn get_centers(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_get_centers( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_get_centers(self.0) } + } + fn set_radii(&mut self, radii: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_spheres_set_radii( + sself: *mut core::ffi::c_void, + radii: *mut core::ffi::c_void, + ); + } + unsafe { vtk_spheres_set_radii(self.0, radii) } + } + fn get_radii(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_get_radii( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_get_radii(self.0) } + } + fn get_number_of_spheres(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_spheres_get_number_of_spheres( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_spheres_get_number_of_spheres(self.0) } + } + fn get_sphere(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spheres_get_sphere( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spheres_get_sphere(self.0, i) } + } +} +impl VtkStaticCellLinks for vtkStaticCellLinks { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_links_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_links_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_links_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_links_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_links_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_links_new_instance(self.0) } + } + fn build_links(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_build_links( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_links_build_links(self.0, ds) } + } + fn get_number_of_cells( + &mut self, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_cell_links_get_number_of_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_cell_links_get_number_of_cells(self.0, ptId) } + } + fn get_ncells(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_cell_links_get_ncells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_cell_links_get_ncells(self.0, ptId) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_cell_links_initialize(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_cell_links_squeeze(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_cell_links_reset(self.0) } + } + fn get_actual_memory_size(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_static_cell_links_get_actual_memory_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_static_cell_links_get_actual_memory_size(self.0) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_static_cell_links_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_links_deep_copy(self.0, src) } + } +} +impl VtkStaticCellLocator for vtkStaticCellLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_cell_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_cell_locator_new_instance(self.0) } + } + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ); + } + unsafe { vtk_static_cell_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_locator_generate_representation(self.0, level, pd) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_cell_locator_build_locator(self.0) } + } + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_set_max_number_of_buckets( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_static_cell_locator_set_max_number_of_buckets(self.0, _arg) } + } + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_cell_locator_get_max_number_of_buckets_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_cell_locator_get_max_number_of_buckets_min_value(self.0) } + } + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_cell_locator_get_max_number_of_buckets_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_cell_locator_get_max_number_of_buckets_max_value(self.0) } + } + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_cell_locator_get_max_number_of_buckets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_cell_locator_get_max_number_of_buckets(self.0) } + } + fn get_large_ids(&mut self) -> bool { + unsafe extern "C" { + fn vtk_static_cell_locator_get_large_ids( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_static_cell_locator_get_large_ids(self.0) } + } + fn set_use_diagonal_length_tolerance(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_set_use_diagonal_length_tolerance( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { + vtk_static_cell_locator_set_use_diagonal_length_tolerance(self.0, _arg) + } + } + fn get_use_diagonal_length_tolerance(&mut self) -> bool { + unsafe extern "C" { + fn vtk_static_cell_locator_get_use_diagonal_length_tolerance( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_static_cell_locator_get_use_diagonal_length_tolerance(self.0) } + } + fn use_diagonal_length_tolerance_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_use_diagonal_length_tolerance_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_locator_use_diagonal_length_tolerance_on(self.0) } + } + fn use_diagonal_length_tolerance_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_cell_locator_use_diagonal_length_tolerance_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_cell_locator_use_diagonal_length_tolerance_off(self.0) } + } +} +impl VtkStaticPointLocator for vtkStaticPointLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_new_instance(self.0) } + } + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_set_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_set_number_of_points_per_bucket(self.0, _arg) } + } + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_get_number_of_points_per_bucket_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_get_number_of_points_per_bucket_min_value(self.0) + } + } + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_get_number_of_points_per_bucket_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_get_number_of_points_per_bucket_max_value(self.0) + } + } + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_get_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_static_point_locator_get_number_of_points_per_bucket(self.0) } + } + fn set_divisions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_set_divisions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_set_divisions(self.0, _arg1, _arg2, _arg3) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_point_locator_initialize(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_point_locator_build_locator(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_generate_representation(self.0, level, pd) } + } + fn get_number_of_points_in_bucket( + &mut self, + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_point_locator_get_number_of_points_in_bucket( + sself: *mut core::ffi::c_void, + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_point_locator_get_number_of_points_in_bucket(self.0, bNum) } + } + fn get_bucket_ids( + &mut self, + bNum: core::ffi::c_longlong, + bList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_get_bucket_ids( + sself: *mut core::ffi::c_void, + bNum: core::ffi::c_longlong, + bList: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_get_bucket_ids(self.0, bNum, bList) } + } + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_set_max_number_of_buckets( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_static_point_locator_set_max_number_of_buckets(self.0, _arg) } + } + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_point_locator_get_max_number_of_buckets_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_point_locator_get_max_number_of_buckets_min_value(self.0) } + } + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_point_locator_get_max_number_of_buckets_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_point_locator_get_max_number_of_buckets_max_value(self.0) } + } + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_point_locator_get_max_number_of_buckets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_point_locator_get_max_number_of_buckets(self.0) } + } + fn get_large_ids(&mut self) -> bool { + unsafe extern "C" { + fn vtk_static_point_locator_get_large_ids( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_static_point_locator_get_large_ids(self.0) } + } +} +impl VtkStaticPointLocator2D for vtkStaticPointLocator2D { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_2_d_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_2_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_static_point_locator_2_d_new_instance(self.0) } + } + fn set_number_of_points_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_set_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_static_point_locator_2_d_set_number_of_points_per_bucket(self.0, _arg) + } + } + fn get_number_of_points_per_bucket_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_2_d_get_number_of_points_per_bucket_min_value( + self.0, + ) + } + } + fn get_number_of_points_per_bucket_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_static_point_locator_2_d_get_number_of_points_per_bucket_max_value( + self.0, + ) + } + } + fn get_number_of_points_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_number_of_points_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_static_point_locator_2_d_get_number_of_points_per_bucket(self.0) } + } + fn set_divisions(&mut self, _arg1: core::ffi::c_int, _arg2: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_set_divisions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + ); + } + unsafe { vtk_static_point_locator_2_d_set_divisions(self.0, _arg1, _arg2) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_point_locator_2_d_initialize(self.0) } + } + fn free_search_structure(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_free_search_structure( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_2_d_free_search_structure(self.0) } + } + fn build_locator(&mut self) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_build_locator(sself: *mut core::ffi::c_void); + } + unsafe { vtk_static_point_locator_2_d_build_locator(self.0) } + } + fn get_number_of_points_in_bucket( + &mut self, + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_number_of_points_in_bucket( + sself: *mut core::ffi::c_void, + bNum: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_static_point_locator_2_d_get_number_of_points_in_bucket(self.0, bNum) + } + } + fn get_bucket_ids( + &mut self, + bNum: core::ffi::c_longlong, + bList: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_bucket_ids( + sself: *mut core::ffi::c_void, + bNum: core::ffi::c_longlong, + bList: *mut core::ffi::c_void, + ); + } + unsafe { vtk_static_point_locator_2_d_get_bucket_ids(self.0, bNum, bList) } + } + fn set_max_number_of_buckets(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_set_max_number_of_buckets( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_static_point_locator_2_d_set_max_number_of_buckets(self.0, _arg) } + } + fn get_max_number_of_buckets_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_static_point_locator_2_d_get_max_number_of_buckets_min_value(self.0) + } + } + fn get_max_number_of_buckets_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { + vtk_static_point_locator_2_d_get_max_number_of_buckets_max_value(self.0) + } + } + fn get_max_number_of_buckets(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_max_number_of_buckets( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_static_point_locator_2_d_get_max_number_of_buckets(self.0) } + } + fn get_large_ids(&mut self) -> bool { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_get_large_ids( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_static_point_locator_2_d_get_large_ids(self.0) } + } + fn generate_representation( + &mut self, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_static_point_locator_2_d_generate_representation( + sself: *mut core::ffi::c_void, + level: core::ffi::c_int, + pd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_static_point_locator_2_d_generate_representation(self.0, level, pd) + } + } +} +impl VtkStructuredExtent for vtkStructuredExtent { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_extent_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_extent_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_extent_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_extent_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_extent_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_extent_new_instance(self.0) } + } +} +impl VtkStructuredGrid for vtkStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_data_object_type(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_grid_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_copy_structure(self.0, ds) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_structured_grid_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_structured_grid_get_number_of_points(self.0) } + } + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_get_cell(self.0, cellId) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_cell_type(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_get_point_cells(self.0, ptId, cellIds) } + } + fn set_dimensions( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_set_dimensions( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ); + } + unsafe { vtk_structured_grid_set_dimensions(self.0, i, j, k) } + } + fn get_data_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_data_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_data_dimension(self.0) } + } + fn set_extent( + &mut self, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_structured_grid_set_extent( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_int, + xMax: core::ffi::c_int, + yMin: core::ffi::c_int, + yMax: core::ffi::c_int, + zMin: core::ffi::c_int, + zMax: core::ffi::c_int, + ); + } + unsafe { + vtk_structured_grid_set_extent(self.0, xMin, xMax, yMin, yMax, zMin, zMax) + } + } + fn get_extent_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_grid_get_extent_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_grid_get_extent_type(self.0) } + } + fn blank_point(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_structured_grid_blank_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_structured_grid_blank_point(self.0, ptId) } + } + fn un_blank_point(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_structured_grid_un_blank_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_structured_grid_un_blank_point(self.0, ptId) } + } + fn blank_cell(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_structured_grid_blank_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_structured_grid_blank_cell(self.0, ptId) } + } + fn un_blank_cell(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_structured_grid_un_blank_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_structured_grid_un_blank_cell(self.0, ptId) } + } + fn is_point_visible(&mut self, ptId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_structured_grid_is_point_visible( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_structured_grid_is_point_visible(self.0, ptId) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_structured_grid_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_structured_grid_is_cell_visible(self.0, cellId) } + } + fn has_any_blank_points(&mut self) -> bool { + unsafe extern "C" { + fn vtk_structured_grid_has_any_blank_points( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_structured_grid_has_any_blank_points(self.0) } + } + fn has_any_blank_cells(&mut self) -> bool { + unsafe extern "C" { + fn vtk_structured_grid_has_any_blank_cells( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_structured_grid_has_any_blank_cells(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_get_data(self.0, info) } + } +} +impl VtkStructuredPoints for vtkStructuredPoints { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_structured_points_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_structured_points_get_data_object_type(self.0) } + } +} +impl VtkStructuredPointsCollection for vtkStructuredPointsCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_collection_new_instance(self.0) } + } + fn add_item(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_points_collection_add_item( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_points_collection_add_item(self.0, ds) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_points_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_points_collection_get_next_item(self.0) } + } +} +impl VtkSuperquadric for vtkSuperquadric { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_new_instance(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_scale( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_scale(self.0, _arg1, _arg2, _arg3) } + } + fn get_thickness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_thickness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_thickness(self.0) } + } + fn set_thickness(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_thickness( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_thickness(self.0, _arg) } + } + fn get_thickness_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_thickness_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_thickness_min_value(self.0) } + } + fn get_thickness_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_thickness_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_thickness_max_value(self.0) } + } + fn get_phi_roundness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_phi_roundness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_phi_roundness(self.0) } + } + fn set_phi_roundness(&mut self, e: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_phi_roundness( + sself: *mut core::ffi::c_void, + e: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_phi_roundness(self.0, e) } + } + fn get_theta_roundness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_theta_roundness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_theta_roundness(self.0) } + } + fn set_theta_roundness(&mut self, e: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_theta_roundness( + sself: *mut core::ffi::c_void, + e: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_theta_roundness(self.0, e) } + } + fn set_size(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_set_size(self.0, _arg) } + } + fn get_size(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_get_size(self.0) } + } + fn toroidal_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_toroidal_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_superquadric_toroidal_on(self.0) } + } + fn toroidal_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_toroidal_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_superquadric_toroidal_off(self.0) } + } + fn get_toroidal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_get_toroidal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_get_toroidal(self.0) } + } + fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_set_toroidal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_set_toroidal(self.0, _arg) } + } +} +impl VtkTable for vtkTable { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_new_instance(self.0) } + } + fn dump(&mut self, colWidth: core::ffi::c_uint, rowLimit: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_table_dump( + sself: *mut core::ffi::c_void, + colWidth: core::ffi::c_uint, + rowLimit: core::ffi::c_int, + ); + } + unsafe { vtk_table_dump(self.0, colWidth, rowLimit) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_table_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_table_get_data_object_type(self.0) } + } + fn get_row_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_row_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_row_data(self.0) } + } + fn set_row_data(&mut self, data: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_table_set_row_data( + sself: *mut core::ffi::c_void, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_set_row_data(self.0, data) } + } + fn get_number_of_rows(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_table_get_number_of_rows( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_table_get_number_of_rows(self.0) } + } + fn set_number_of_rows(&mut self, p0: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_table_set_number_of_rows( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_longlong, + ); + } + unsafe { vtk_table_set_number_of_rows(self.0, p0) } + } + fn get_row(&mut self, row: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_row( + sself: *mut core::ffi::c_void, + row: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_row(self.0, row) } + } + fn set_row( + &mut self, + row: core::ffi::c_longlong, + values: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_table_set_row( + sself: *mut core::ffi::c_void, + row: core::ffi::c_longlong, + values: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_set_row(self.0, row, values) } + } + fn insert_next_blank_row( + &mut self, + default_num_val: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_table_insert_next_blank_row( + sself: *mut core::ffi::c_void, + default_num_val: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_table_insert_next_blank_row(self.0, default_num_val) } + } + fn insert_next_row( + &mut self, + values: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_table_insert_next_row( + sself: *mut core::ffi::c_void, + values: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_table_insert_next_row(self.0, values) } + } + fn remove_row(&mut self, row: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_table_remove_row( + sself: *mut core::ffi::c_void, + row: core::ffi::c_longlong, + ); + } + unsafe { vtk_table_remove_row(self.0, row) } + } + fn get_number_of_columns(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_table_get_number_of_columns( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_table_get_number_of_columns(self.0) } + } + fn get_column_name(&mut self, col: core::ffi::c_longlong) -> &str { + unsafe extern "C" { + fn vtk_table_get_column_name( + sself: *mut core::ffi::c_void, + col: core::ffi::c_longlong, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_table_get_column_name(self.0, col) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_column_by_name(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_table_get_column_by_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_column_by_name(self.0, c_name.as_ptr()) } + } + fn get_column(&mut self, col: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_column( + sself: *mut core::ffi::c_void, + col: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_column(self.0, col) } + } + fn add_column(&mut self, arr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_table_add_column( + sself: *mut core::ffi::c_void, + arr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_add_column(self.0, arr) } + } + fn remove_column_by_name(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_table_remove_column_by_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_table_remove_column_by_name(self.0, c_name.as_ptr()) } + } + fn remove_column(&mut self, col: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_table_remove_column( + sself: *mut core::ffi::c_void, + col: core::ffi::c_longlong, + ); + } + unsafe { vtk_table_remove_column(self.0, col) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_table_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_table_initialize(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_get_data(self.0, info) } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_table_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_shallow_copy(self.0, src) } + } + fn get_number_of_elements( + &mut self, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_table_get_number_of_elements( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_table_get_number_of_elements(self.0, type_) } + } +} +impl VtkTetra for vtkTetra { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tetra_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tetra_get_face(self.0, faceId) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tetra_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tetra_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkTree for vtkTree { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_new_instance(self.0) } + } + fn get_root(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_tree_get_root(sself: *mut core::ffi::c_void) -> core::ffi::c_longlong; + } + unsafe { vtk_tree_get_root(self.0) } + } + fn get_number_of_children( + &mut self, + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_tree_get_number_of_children( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_tree_get_number_of_children(self.0, v) } + } + fn get_child( + &mut self, + v: core::ffi::c_longlong, + i: core::ffi::c_longlong, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_tree_get_child( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + i: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_tree_get_child(self.0, v, i) } + } + fn get_children( + &mut self, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_tree_get_children( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tree_get_children(self.0, v, it) } + } + fn get_parent(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_tree_get_parent( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_tree_get_parent(self.0, v) } + } + fn get_level(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_tree_get_level( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_tree_get_level(self.0, v) } + } + fn is_leaf(&mut self, vertex: core::ffi::c_longlong) -> bool { + unsafe extern "C" { + fn vtk_tree_is_leaf( + sself: *mut core::ffi::c_void, + vertex: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_tree_is_leaf(self.0, vertex) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_get_data(self.0, info) } + } + fn reorder_children( + &mut self, + parent: core::ffi::c_longlong, + children: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_tree_reorder_children( + sself: *mut core::ffi::c_void, + parent: core::ffi::c_longlong, + children: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tree_reorder_children(self.0, parent, children) } + } +} +impl VtkTreeBFSIterator for vtkTreeBFSIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_bfs_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_bfs_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_bfs_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_bfs_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_bfs_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_bfs_iterator_new_instance(self.0) } + } +} +impl VtkTreeDFSIterator for vtkTreeDFSIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_dfs_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_dfs_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_dfs_iterator_new_instance(self.0) } + } + fn set_mode(&mut self, mode: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_set_mode( + sself: *mut core::ffi::c_void, + mode: core::ffi::c_int, + ); + } + unsafe { vtk_tree_dfs_iterator_set_mode(self.0, mode) } + } + fn get_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tree_dfs_iterator_get_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tree_dfs_iterator_get_mode(self.0) } + } +} +impl VtkTriQuadraticHexahedron for vtkTriQuadraticHexahedron { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_hexahedron_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_hexahedron_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_hexahedron_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tetras: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_tri_quadratic_hexahedron_clip( + self.0, + value, + cellScalars, + locator, + tetras, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkTriQuadraticPyramid for vtkTriQuadraticPyramid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tri_quadratic_pyramid_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tri_quadratic_pyramid_triangulate(self.0, index, ptIds, pts) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_tri_quadratic_pyramid_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + tets: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_tri_quadratic_pyramid_clip( + self.0, + value, + cellScalars, + locator, + tets, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkTriangle for vtkTriangle { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_new_instance(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_get_edge(self.0, edgeId) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_get_number_of_faces(self.0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_get_face(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_triangle_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_triangulate(self.0, index, ptIds, pts) } + } + fn compute_area(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_triangle_compute_area( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_triangle_compute_area(self.0) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_triangle_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } +} +impl VtkTriangleStrip for vtkTriangleStrip { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_triangle_strip_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_triangle_strip_get_face(self.0, faceId) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_strip_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_triangle_strip_contour( + self.0, + value, + cellScalars, + locator, + verts, + lines, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_triangle_strip_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + polys: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_triangle_strip_clip( + self.0, + value, + cellScalars, + locator, + polys, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_triangle_strip_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_triangle_strip_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkUndirectedGraph for vtkUndirectedGraph { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_new_instance(self.0) } + } + fn get_in_degree(&mut self, v: core::ffi::c_longlong) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_undirected_graph_get_in_degree( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_undirected_graph_get_in_degree(self.0, v) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_get_data(self.0, info) } + } + fn get_in_edges( + &mut self, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_undirected_graph_get_in_edges( + sself: *mut core::ffi::c_void, + v: core::ffi::c_longlong, + it: *mut core::ffi::c_void, + ); + } + unsafe { vtk_undirected_graph_get_in_edges(self.0, v, it) } + } + fn is_structure_valid(&mut self, g: *mut core::ffi::c_void) -> bool { + unsafe extern "C" { + fn vtk_undirected_graph_is_structure_valid( + sself: *mut core::ffi::c_void, + g: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_undirected_graph_is_structure_valid(self.0, g) } + } +} +impl VtkUniformGrid for vtkUniformGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_new_instance(self.0) } + } + fn get_cell( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_get_cell( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + k: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_get_cell(self.0, i, j, k) } + } + fn get_grid_description(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_get_grid_description( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_get_grid_description(self.0) } + } + fn blank_point(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_blank_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_uniform_grid_blank_point(self.0, ptId) } + } + fn un_blank_point(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_un_blank_point( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_uniform_grid_un_blank_point(self.0, ptId) } + } + fn blank_cell(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_blank_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_uniform_grid_blank_cell(self.0, ptId) } + } + fn un_blank_cell(&mut self, ptId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_un_blank_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + ); + } + unsafe { vtk_uniform_grid_un_blank_cell(self.0, ptId) } + } + fn is_point_visible( + &mut self, + pointId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_uniform_grid_is_point_visible( + sself: *mut core::ffi::c_void, + pointId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_uniform_grid_is_point_visible(self.0, pointId) } + } + fn is_cell_visible(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_uchar { + unsafe extern "C" { + fn vtk_uniform_grid_is_cell_visible( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_uchar; + } + unsafe { vtk_uniform_grid_is_cell_visible(self.0, cellId) } + } + fn new_image_data_copy(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_new_image_data_copy( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_new_image_data_copy(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_get_data(self.0, info) } + } +} +impl VtkUniformGridAMR for vtkUniformGridAMR { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_new_instance(self.0) } + } + fn new_iterator(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_new_iterator( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_new_iterator(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_get_data_object_type(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_uniform_grid_amr_initialize(self.0) } + } + fn set_grid_description(&mut self, gridDescription: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_set_grid_description( + sself: *mut core::ffi::c_void, + gridDescription: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_amr_set_grid_description(self.0, gridDescription) } + } + fn get_grid_description(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_grid_description( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_get_grid_description(self.0) } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_get_number_of_levels(self.0) } + } + fn get_total_number_of_blocks(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_total_number_of_blocks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_get_total_number_of_blocks(self.0) } + } + fn get_number_of_data_sets( + &mut self, + level: core::ffi::c_uint, + ) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_number_of_data_sets( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_get_number_of_data_sets(self.0, level) } + } + fn set_data_set( + &mut self, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_set_data_set( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + dataObj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_set_data_set(self.0, iter, dataObj) } + } + fn get_data_set(&mut self, iter: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_data_set( + sself: *mut core::ffi::c_void, + iter: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_get_data_set(self.0, iter) } + } + fn get_composite_index( + &mut self, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_composite_index( + sself: *mut core::ffi::c_void, + level: core::ffi::c_uint, + index: core::ffi::c_uint, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_get_composite_index(self.0, level, index) } + } + fn get_level_and_index( + &mut self, + compositeIdx: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + idx: &mut core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_level_and_index( + sself: *mut core::ffi::c_void, + compositeIdx: core::ffi::c_uint, + level: &mut core::ffi::c_uint, + idx: &mut core::ffi::c_uint, + ); + } + unsafe { + vtk_uniform_grid_amr_get_level_and_index(self.0, compositeIdx, level, idx) + } + } + fn shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_shallow_copy(self.0, src) } + } + fn deep_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_deep_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_deep_copy(self.0, src) } + } + fn copy_structure(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_copy_structure( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_copy_structure(self.0, src) } + } + fn recursive_shallow_copy(&mut self, src: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_recursive_shallow_copy( + sself: *mut core::ffi::c_void, + src: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_recursive_shallow_copy(self.0, src) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_get_data(self.0, info) } + } +} +impl VtkUniformGridAMRDataIterator for vtkUniformGridAMRDataIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_new_instance(self.0) } + } + fn get_current_meta_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_meta_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_meta_data(self.0) } + } + fn has_current_meta_data(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_has_current_meta_data( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_data_iterator_has_current_meta_data(self.0) } + } + fn get_current_data_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_data_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_data_object(self.0) } + } + fn get_current_flat_index(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_flat_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_flat_index(self.0) } + } + fn get_current_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_level(self.0) } + } + fn get_current_index(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_get_current_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_uniform_grid_amr_data_iterator_get_current_index(self.0) } + } + fn go_to_first_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_go_to_first_item( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_data_iterator_go_to_first_item(self.0) } + } + fn go_to_next_item(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_go_to_next_item( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_data_iterator_go_to_next_item(self.0) } + } + fn is_done_with_traversal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_amr_data_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_amr_data_iterator_is_done_with_traversal(self.0) } + } +} +impl VtkUniformHyperTreeGrid for vtkUniformHyperTreeGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_new_instance(self.0) } + } + fn copy_structure(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_copy_structure( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_copy_structure(self.0, p0) } + } + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_origin(self.0, _arg1, _arg2, _arg3) } + } + fn set_grid_scale( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_grid_scale( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_grid_scale(self.0, p0, p1, p2) } + } + fn set_x_coordinates(&mut self, XCoordinates: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_x_coordinates( + sself: *mut core::ffi::c_void, + XCoordinates: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_x_coordinates(self.0, XCoordinates) } + } + fn set_y_coordinates(&mut self, YCoordinates: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_y_coordinates( + sself: *mut core::ffi::c_void, + YCoordinates: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_y_coordinates(self.0, YCoordinates) } + } + fn set_z_coordinates(&mut self, ZCoordinates: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_set_z_coordinates( + sself: *mut core::ffi::c_void, + ZCoordinates: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_hyper_tree_grid_set_z_coordinates(self.0, ZCoordinates) } + } + fn get_actual_memory_size_bytes(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_uniform_hyper_tree_grid_get_actual_memory_size_bytes(self.0) } + } +} +impl VtkUnstructuredGrid for vtkUnstructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_new(self.0) } + } + fn extended_new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_extended_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_extended_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_new_instance(self.0) } + } + fn get_data_object_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_data_object_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_data_object_type(self.0) } + } + fn allocate_estimate( + &mut self, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool { + unsafe extern "C" { + fn vtk_unstructured_grid_allocate_estimate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + maxCellSize: core::ffi::c_longlong, + ) -> bool; + } + unsafe { vtk_unstructured_grid_allocate_estimate(self.0, numCells, maxCellSize) } + } + fn allocate_exact( + &mut self, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool { + unsafe extern "C" { + fn vtk_unstructured_grid_allocate_exact( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + connectivitySize: core::ffi::c_longlong, + ) -> bool; + } + unsafe { + vtk_unstructured_grid_allocate_exact(self.0, numCells, connectivitySize) + } + } + fn allocate( + &mut self, + numCells: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_allocate( + sself: *mut core::ffi::c_void, + numCells: core::ffi::c_longlong, + extSize: core::ffi::c_int, + ); + } + unsafe { vtk_unstructured_grid_allocate(self.0, numCells, extSize) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_reset(self.0) } + } + fn copy_structure(&mut self, ds: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_copy_structure( + sself: *mut core::ffi::c_void, + ds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_copy_structure(self.0, ds) } + } + fn get_cell(&mut self, cellId: core::ffi::c_longlong) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cell(self.0, cellId) } + } + fn get_cell_points( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_points( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_cell_points(self.0, cellId, ptIds) } + } + fn get_point_cells( + &mut self, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_point_cells( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_point_cells(self.0, ptId, cellIds) } + } + fn get_cell_type(&mut self, cellId: core::ffi::c_longlong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_type( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_cell_type(self.0, cellId) } + } + fn get_cell_types(&mut self, types: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_types( + sself: *mut core::ffi::c_void, + types: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_cell_types(self.0, types) } + } + fn get_cell_types_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_types_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cell_types_array(self.0) } + } + fn squeeze(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_squeeze(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_squeeze(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_initialize(self.0) } + } + fn get_max_cell_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_max_cell_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_max_cell_size(self.0) } + } + fn build_links(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_build_links(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_build_links(self.0) } + } + fn get_cell_links(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_links( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cell_links(self.0) } + } + fn get_face_stream( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_face_stream( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_face_stream(self.0, cellId, ptIds) } + } + fn set_cells( + &mut self, + type_: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_set_cells( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + cells: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_set_cells(self.0, type_, cells) } + } + fn get_cells(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cells( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cells(self.0) } + } + fn get_cell_neighbors( + &mut self, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_neighbors( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellIds: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_get_cell_neighbors(self.0, cellId, ptIds, cellIds) + } + } + fn remove_reference_to_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_remove_reference_to_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_unstructured_grid_remove_reference_to_cell(self.0, ptId, cellId) } + } + fn add_reference_to_cell( + &mut self, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_add_reference_to_cell( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_unstructured_grid_add_reference_to_cell(self.0, ptId, cellId) } + } + fn resize_cell_list( + &mut self, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_resize_cell_list( + sself: *mut core::ffi::c_void, + ptId: core::ffi::c_longlong, + size: core::ffi::c_int, + ); + } + unsafe { vtk_unstructured_grid_resize_cell_list(self.0, ptId, size) } + } + fn get_piece(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_piece( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_piece(self.0) } + } + fn get_number_of_pieces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_number_of_pieces(self.0) } + } + fn get_ghost_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_get_ghost_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_get_ghost_level(self.0) } + } + fn get_ids_of_cells_of_type( + &mut self, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_get_ids_of_cells_of_type( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + array: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_get_ids_of_cells_of_type(self.0, type_, array) } + } + fn is_homogeneous(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_is_homogeneous( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_unstructured_grid_is_homogeneous(self.0) } + } + fn remove_ghost_cells(&mut self) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_remove_ghost_cells(sself: *mut core::ffi::c_void); + } + unsafe { vtk_unstructured_grid_remove_ghost_cells(self.0) } + } + fn get_data(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_data( + sself: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_data(self.0, info) } + } + fn get_face_locations(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_face_locations( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_face_locations(self.0) } + } + fn initialize_faces_representation( + &mut self, + numPrevCells: core::ffi::c_longlong, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_unstructured_grid_initialize_faces_representation( + sself: *mut core::ffi::c_void, + numPrevCells: core::ffi::c_longlong, + ) -> core::ffi::c_int; + } + unsafe { + vtk_unstructured_grid_initialize_faces_representation(self.0, numPrevCells) + } + } + fn get_mesh_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_unstructured_grid_get_mesh_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_unstructured_grid_get_mesh_m_time(self.0) } + } + fn decompose_a_polyhedron_cell( + &mut self, + polyhedronCellArray: *mut core::ffi::c_void, + nCellpts: &mut core::ffi::c_longlong, + nCellfaces: &mut core::ffi::c_longlong, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_decompose_a_polyhedron_cell( + sself: *mut core::ffi::c_void, + polyhedronCellArray: *mut core::ffi::c_void, + nCellpts: &mut core::ffi::c_longlong, + nCellfaces: &mut core::ffi::c_longlong, + cellArray: *mut core::ffi::c_void, + faces: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_unstructured_grid_decompose_a_polyhedron_cell( + self.0, + polyhedronCellArray, + nCellpts, + nCellfaces, + cellArray, + faces, + ) + } + } + fn get_cell_locations_array(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_get_cell_locations_array( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_get_cell_locations_array(self.0) } + } +} +impl VtkUnstructuredGridCellIterator for vtkUnstructuredGridCellIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_cell_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_cell_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_cell_iterator_new_instance(self.0) } + } + fn is_done_with_traversal(&mut self) -> bool { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_is_done_with_traversal( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_unstructured_grid_cell_iterator_is_done_with_traversal(self.0) } + } + fn get_cell_id(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_get_cell_id( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_unstructured_grid_cell_iterator_get_cell_id(self.0) } + } + fn go_to_cell(&mut self, cellId: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_cell_iterator_go_to_cell( + sself: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + ); + } + unsafe { vtk_unstructured_grid_cell_iterator_go_to_cell(self.0, cellId) } + } +} +impl VtkVertex for vtkVertex { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_cell_type(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_cell_dimension(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_get_edge( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_get_edge(self.0, p0) } + } + fn get_face(&mut self, p0: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_get_face( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_get_face(self.0, p0) } + } + fn clip( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_clip( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + insideOut: core::ffi::c_int, + ); + } + unsafe { + vtk_vertex_clip( + self.0, + value, + cellScalars, + locator, + pts, + inPd, + outPd, + inCd, + cellId, + outCd, + insideOut, + ) + } + } + fn inflate(&mut self, p0: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_inflate( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_inflate(self.0, p0) } + } + fn contour( + &mut self, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_vertex_contour( + sself: *mut core::ffi::c_void, + value: core::ffi::c_double, + cellScalars: *mut core::ffi::c_void, + locator: *mut core::ffi::c_void, + verts1: *mut core::ffi::c_void, + lines: *mut core::ffi::c_void, + verts2: *mut core::ffi::c_void, + inPd: *mut core::ffi::c_void, + outPd: *mut core::ffi::c_void, + inCd: *mut core::ffi::c_void, + cellId: core::ffi::c_longlong, + outCd: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_vertex_contour( + self.0, + value, + cellScalars, + locator, + verts1, + lines, + verts2, + inPd, + outPd, + inCd, + cellId, + outCd, + ) + } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_vertex_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_vertex_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkVertexListIterator for vtkVertexListIterator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_list_iterator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_list_iterator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_list_iterator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_list_iterator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_list_iterator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_list_iterator_new_instance(self.0) } + } + fn set_graph(&mut self, graph: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_vertex_list_iterator_set_graph( + sself: *mut core::ffi::c_void, + graph: *mut core::ffi::c_void, + ); + } + unsafe { vtk_vertex_list_iterator_set_graph(self.0, graph) } + } + fn get_graph(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_vertex_list_iterator_get_graph( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_vertex_list_iterator_get_graph(self.0) } + } + fn next(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_vertex_list_iterator_next( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_vertex_list_iterator_next(self.0) } + } + fn has_next(&mut self) -> bool { + unsafe extern "C" { + fn vtk_vertex_list_iterator_has_next(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_vertex_list_iterator_has_next(self.0) } + } +} +impl VtkVoxel for vtkVoxel { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_voxel_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_voxel_get_face(self.0, faceId) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_triangulate(self.0, index, ptIds, pts) } + } + fn inflate(&mut self, dist: core::ffi::c_double) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_voxel_inflate( + sself: *mut core::ffi::c_void, + dist: core::ffi::c_double, + ) -> core::ffi::c_int; + } + unsafe { vtk_voxel_inflate(self.0, dist) } + } +} +impl VtkWedge for vtkWedge { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_new_instance(self.0) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_get_cell_type(self.0) } + } + fn get_number_of_edges(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_get_number_of_edges( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_get_number_of_edges(self.0) } + } + fn get_number_of_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_get_number_of_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_get_number_of_faces(self.0) } + } + fn get_edge(&mut self, edgeId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_get_edge( + sself: *mut core::ffi::c_void, + edgeId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_get_edge(self.0, edgeId) } + } + fn get_face(&mut self, faceId: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_wedge_get_face( + sself: *mut core::ffi::c_void, + faceId: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_wedge_get_face(self.0, faceId) } + } + fn triangulate( + &mut self, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_wedge_triangulate( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ptIds: *mut core::ffi::c_void, + pts: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_wedge_triangulate(self.0, index, ptIds, pts) } + } +} +impl VtkXMLDataElement for vtkXMLDataElement { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_new(self.0) } + } + fn set_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_set_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_set_name(self.0, c__arg.as_ptr()) } + } + fn set_id(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_set_id( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_set_id(self.0, c__arg.as_ptr()) } + } + fn get_attribute(&mut self, name: &str) -> &str { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_xml_data_element_get_attribute(self.0, c_name.as_ptr()) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_attribute(&mut self, name: &str, value: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_value = std::ffi::CString::new(value).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_set_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + value: *const core::ffi::c_char, + ); + } + unsafe { + vtk_xml_data_element_set_attribute(self.0, c_name.as_ptr(), c_value.as_ptr()) + } + } + fn set_character_data(&mut self, data: &str, length: core::ffi::c_int) -> () { + let c_data = std::ffi::CString::new(data).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_set_character_data( + sself: *mut core::ffi::c_void, + data: *const core::ffi::c_char, + length: core::ffi::c_int, + ); + } + unsafe { + vtk_xml_data_element_set_character_data(self.0, c_data.as_ptr(), length) + } + } + fn add_character_data(&mut self, c: &str, length: usize) -> () { + let c_c = std::ffi::CString::new(c).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_add_character_data( + sself: *mut core::ffi::c_void, + c: *const core::ffi::c_char, + length: usize, + ); + } + unsafe { vtk_xml_data_element_add_character_data(self.0, c_c.as_ptr(), length) } + } + fn get_scalar_attribute( + &mut self, + name: &str, + value: &mut core::ffi::c_int, + ) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_get_scalar_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + value: &mut core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_xml_data_element_get_scalar_attribute(self.0, c_name.as_ptr(), value) + } + } + fn set_int_attribute(&mut self, name: &str, value: core::ffi::c_int) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_set_int_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + value: core::ffi::c_int, + ); + } + unsafe { vtk_xml_data_element_set_int_attribute(self.0, c_name.as_ptr(), value) } + } + fn set_float_attribute(&mut self, name: &str, value: core::ffi::c_float) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_set_float_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + value: core::ffi::c_float, + ); + } + unsafe { + vtk_xml_data_element_set_float_attribute(self.0, c_name.as_ptr(), value) + } + } + fn set_double_attribute(&mut self, name: &str, value: core::ffi::c_double) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_set_double_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_xml_data_element_set_double_attribute(self.0, c_name.as_ptr(), value) + } + } + fn set_unsigned_long_attribute( + &mut self, + name: &str, + value: core::ffi::c_ulong, + ) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_set_unsigned_long_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + value: core::ffi::c_ulong, + ); + } + unsafe { + vtk_xml_data_element_set_unsigned_long_attribute( + self.0, + c_name.as_ptr(), + value, + ) + } + } + fn get_word_type_attribute( + &mut self, + name: &str, + value: &mut core::ffi::c_int, + ) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_get_word_type_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + value: &mut core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_xml_data_element_get_word_type_attribute(self.0, c_name.as_ptr(), value) + } + } + fn get_number_of_attributes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_number_of_attributes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_number_of_attributes(self.0) } + } + fn get_attribute_name(&mut self, idx: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_name( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_xml_data_element_get_attribute_name(self.0, idx) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_attribute_value(&mut self, idx: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_value( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_xml_data_element_get_attribute_value(self.0, idx) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn remove_attribute(&mut self, name: &str) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_remove_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_remove_attribute(self.0, c_name.as_ptr()) } + } + fn remove_all_attributes(&mut self) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_remove_all_attributes(sself: *mut core::ffi::c_void); + } + unsafe { vtk_xml_data_element_remove_all_attributes(self.0) } + } + fn get_parent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_get_parent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_get_parent(self.0) } + } + fn set_parent(&mut self, parent: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_parent( + sself: *mut core::ffi::c_void, + parent: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_set_parent(self.0, parent) } + } + fn get_root(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_get_root( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_get_root(self.0) } + } + fn get_number_of_nested_elements(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_number_of_nested_elements( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_number_of_nested_elements(self.0) } + } + fn get_nested_element(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_xml_data_element_get_nested_element( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_get_nested_element(self.0, index) } + } + fn add_nested_element(&mut self, element: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_add_nested_element( + sself: *mut core::ffi::c_void, + element: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_add_nested_element(self.0, element) } + } + fn remove_nested_element(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_remove_nested_element( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_remove_nested_element(self.0, p0) } + } + fn remove_all_nested_elements(&mut self) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_remove_all_nested_elements( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_remove_all_nested_elements(self.0) } + } + fn find_nested_element(&mut self, id: &str) -> *mut core::ffi::c_void { + let c_id = std::ffi::CString::new(id).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_find_nested_element( + sself: *mut core::ffi::c_void, + id: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_find_nested_element(self.0, c_id.as_ptr()) } + } + fn find_nested_element_with_name(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_find_nested_element_with_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_xml_data_element_find_nested_element_with_name(self.0, c_name.as_ptr()) + } + } + fn find_nested_element_with_name_and_id( + &mut self, + name: &str, + id: &str, + ) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_id = std::ffi::CString::new(id).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_find_nested_element_with_name_and_id( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + id: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_xml_data_element_find_nested_element_with_name_and_id( + self.0, + c_name.as_ptr(), + c_id.as_ptr(), + ) + } + } + fn find_nested_element_with_name_and_attribute( + &mut self, + name: &str, + att_name: &str, + att_value: &str, + ) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + let c_att_name = std::ffi::CString::new(att_name).expect("CString::new failed"); + let c_att_value = std::ffi::CString::new(att_value) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_find_nested_element_with_name_and_attribute( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + att_name: *const core::ffi::c_char, + att_value: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_xml_data_element_find_nested_element_with_name_and_attribute( + self.0, + c_name.as_ptr(), + c_att_name.as_ptr(), + c_att_value.as_ptr(), + ) + } + } + fn lookup_element_with_name(&mut self, name: &str) -> *mut core::ffi::c_void { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_lookup_element_with_name( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_lookup_element_with_name(self.0, c_name.as_ptr()) } + } + fn lookup_element(&mut self, id: &str) -> *mut core::ffi::c_void { + let c_id = std::ffi::CString::new(id).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_lookup_element( + sself: *mut core::ffi::c_void, + id: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_xml_data_element_lookup_element(self.0, c_id.as_ptr()) } + } + fn get_xml_byte_index(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_xml_data_element_get_xml_byte_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_xml_data_element_get_xml_byte_index(self.0) } + } + fn set_xml_byte_index(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_xml_byte_index( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_xml_data_element_set_xml_byte_index(self.0, _arg) } + } + fn is_equal_to(&mut self, elem: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_is_equal_to( + sself: *mut core::ffi::c_void, + elem: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_is_equal_to(self.0, elem) } + } + fn deep_copy(&mut self, elem: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_deep_copy( + sself: *mut core::ffi::c_void, + elem: *mut core::ffi::c_void, + ); + } + unsafe { vtk_xml_data_element_deep_copy(self.0, elem) } + } + fn set_attribute_encoding(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_attribute_encoding( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_xml_data_element_set_attribute_encoding(self.0, _arg) } + } + fn get_attribute_encoding_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_encoding_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_attribute_encoding_min_value(self.0) } + } + fn get_attribute_encoding_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_encoding_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_attribute_encoding_max_value(self.0) } + } + fn get_attribute_encoding(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_attribute_encoding( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_attribute_encoding(self.0) } + } + fn print_xml(&mut self, fname: &str) -> () { + let c_fname = std::ffi::CString::new(fname).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_xml_data_element_print_xml( + sself: *mut core::ffi::c_void, + fname: *const core::ffi::c_char, + ); + } + unsafe { vtk_xml_data_element_print_xml(self.0, c_fname.as_ptr()) } + } + fn get_character_data_width(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_xml_data_element_get_character_data_width( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_xml_data_element_get_character_data_width(self.0) } + } + fn set_character_data_width(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_xml_data_element_set_character_data_width( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_xml_data_element_set_character_data_width(self.0, _arg) } + } +} /// container of vtkUniformGrid for an AMR data set /// /// @@ -9,22 +37084,13 @@ #[allow(non_camel_case_types)] pub struct vtkAMRDataInternals(*mut core::ffi::c_void); impl vtkAMRDataInternals { - /// Creates a new [vtkAMRDataInternals] wrapped inside `vtkNew` + /// Creates a new [vtkAMRDataInternals] via `vtkAMRDataInternals::New()` #[doc(alias = "vtkAMRDataInternals")] pub fn new() -> Self { - unsafe extern "C" { - fn vtkAMRDataInternals_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkAMRDataInternals_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAMRDataInternals_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + unsafe extern "C" { + fn vtkAMRDataInternals_new() -> *mut core::ffi::c_void; } - unsafe { vtkAMRDataInternals_get_ptr(self.0) } + Self(unsafe { vtkAMRDataInternals_new() }) } } impl std::default::Default for vtkAMRDataInternals { @@ -44,12 +37110,8 @@ impl Drop for vtkAMRDataInternals { #[test] fn test_vtkAMRDataInternals_create_drop() { let obj = vtkAMRDataInternals::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAMRDataInternals(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates through adjacent vertices in a graph. /// @@ -62,22 +37124,13 @@ fn test_vtkAMRDataInternals_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAdjacentVertexIterator(*mut core::ffi::c_void); impl vtkAdjacentVertexIterator { - /// Creates a new [vtkAdjacentVertexIterator] wrapped inside `vtkNew` + /// Creates a new [vtkAdjacentVertexIterator] via `vtkAdjacentVertexIterator::New()` #[doc(alias = "vtkAdjacentVertexIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkAdjacentVertexIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAdjacentVertexIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAdjacentVertexIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAdjacentVertexIterator_get_ptr(self.0) } + Self(unsafe { vtkAdjacentVertexIterator_new() }) } } impl std::default::Default for vtkAdjacentVertexIterator { @@ -97,12 +37150,8 @@ impl Drop for vtkAdjacentVertexIterator { #[test] fn test_vtkAdjacentVertexIterator_create_drop() { let obj = vtkAdjacentVertexIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAdjacentVertexIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// the animation scene manager. /// @@ -119,22 +37168,13 @@ fn test_vtkAdjacentVertexIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAnimationScene(*mut core::ffi::c_void); impl vtkAnimationScene { - /// Creates a new [vtkAnimationScene] wrapped inside `vtkNew` + /// Creates a new [vtkAnimationScene] via `vtkAnimationScene::New()` #[doc(alias = "vtkAnimationScene")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnimationScene_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnimationScene_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnimationScene_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnimationScene_get_ptr(self.0) } + Self(unsafe { vtkAnimationScene_new() }) } } impl std::default::Default for vtkAnimationScene { @@ -154,12 +37194,8 @@ impl Drop for vtkAnimationScene { #[test] fn test_vtkAnimationScene_create_drop() { let obj = vtkAnimationScene::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnimationScene(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Stores a collection of annotation artifacts. /// @@ -175,22 +37211,13 @@ fn test_vtkAnimationScene_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAnnotation(*mut core::ffi::c_void); impl vtkAnnotation { - /// Creates a new [vtkAnnotation] wrapped inside `vtkNew` + /// Creates a new [vtkAnnotation] via `vtkAnnotation::New()` #[doc(alias = "vtkAnnotation")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnnotation_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnnotation_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnnotation_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnnotation_get_ptr(self.0) } + Self(unsafe { vtkAnnotation_new() }) } } impl std::default::Default for vtkAnnotation { @@ -210,12 +37237,8 @@ impl Drop for vtkAnnotation { #[test] fn test_vtkAnnotation_create_drop() { let obj = vtkAnnotation::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnnotation(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Stores a ordered collection of annotation sets /// @@ -228,22 +37251,13 @@ fn test_vtkAnnotation_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAnnotationLayers(*mut core::ffi::c_void); impl vtkAnnotationLayers { - /// Creates a new [vtkAnnotationLayers] wrapped inside `vtkNew` + /// Creates a new [vtkAnnotationLayers] via `vtkAnnotationLayers::New()` #[doc(alias = "vtkAnnotationLayers")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnnotationLayers_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnnotationLayers_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnnotationLayers_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnnotationLayers_get_ptr(self.0) } + Self(unsafe { vtkAnnotationLayers_new() }) } } impl std::default::Default for vtkAnnotationLayers { @@ -263,12 +37277,8 @@ impl Drop for vtkAnnotationLayers { #[test] fn test_vtkAnnotationLayers_create_drop() { let obj = vtkAnnotationLayers::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnnotationLayers(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Pipeline data object that contains multiple vtkArray objects. /// @@ -288,22 +37298,13 @@ fn test_vtkAnnotationLayers_create_drop() { #[allow(non_camel_case_types)] pub struct vtkArrayData(*mut core::ffi::c_void); impl vtkArrayData { - /// Creates a new [vtkArrayData] wrapped inside `vtkNew` + /// Creates a new [vtkArrayData] via `vtkArrayData::New()` #[doc(alias = "vtkArrayData")] pub fn new() -> Self { unsafe extern "C" { fn vtkArrayData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkArrayData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkArrayData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkArrayData_get_ptr(self.0) } + Self(unsafe { vtkArrayData_new() }) } } impl std::default::Default for vtkArrayData { @@ -323,12 +37324,8 @@ impl Drop for vtkArrayData { #[test] fn test_vtkArrayData_create_drop() { let obj = vtkArrayData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkArrayData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects that compute /// @@ -343,22 +37340,13 @@ fn test_vtkArrayData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAttributesErrorMetric(*mut core::ffi::c_void); impl vtkAttributesErrorMetric { - /// Creates a new [vtkAttributesErrorMetric] wrapped inside `vtkNew` + /// Creates a new [vtkAttributesErrorMetric] via `vtkAttributesErrorMetric::New()` #[doc(alias = "vtkAttributesErrorMetric")] pub fn new() -> Self { unsafe extern "C" { fn vtkAttributesErrorMetric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAttributesErrorMetric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAttributesErrorMetric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAttributesErrorMetric_get_ptr(self.0) } + Self(unsafe { vtkAttributesErrorMetric_new() }) } } impl std::default::Default for vtkAttributesErrorMetric { @@ -378,12 +37366,8 @@ impl Drop for vtkAttributesErrorMetric { #[test] fn test_vtkAttributesErrorMetric_create_drop() { let obj = vtkAttributesErrorMetric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAttributesErrorMetric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// This class represents an axis-aligned Binary Spatial /// @@ -401,22 +37385,13 @@ fn test_vtkAttributesErrorMetric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBSPCuts(*mut core::ffi::c_void); impl vtkBSPCuts { - /// Creates a new [vtkBSPCuts] wrapped inside `vtkNew` + /// Creates a new [vtkBSPCuts] via `vtkBSPCuts::New()` #[doc(alias = "vtkBSPCuts")] pub fn new() -> Self { unsafe extern "C" { fn vtkBSPCuts_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBSPCuts_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBSPCuts_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBSPCuts_get_ptr(self.0) } + Self(unsafe { vtkBSPCuts_new() }) } } impl std::default::Default for vtkBSPCuts { @@ -436,12 +37411,8 @@ impl Drop for vtkBSPCuts { #[test] fn test_vtkBSPCuts_create_drop() { let obj = vtkBSPCuts::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBSPCuts(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Perform calculations (mostly intersection /// @@ -457,22 +37428,13 @@ fn test_vtkBSPCuts_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBSPIntersections(*mut core::ffi::c_void); impl vtkBSPIntersections { - /// Creates a new [vtkBSPIntersections] wrapped inside `vtkNew` + /// Creates a new [vtkBSPIntersections] via `vtkBSPIntersections::New()` #[doc(alias = "vtkBSPIntersections")] pub fn new() -> Self { unsafe extern "C" { fn vtkBSPIntersections_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBSPIntersections_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBSPIntersections_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBSPIntersections_get_ptr(self.0) } + Self(unsafe { vtkBSPIntersections_new() }) } } impl std::default::Default for vtkBSPIntersections { @@ -492,33 +37454,20 @@ impl Drop for vtkBSPIntersections { #[test] fn test_vtkBSPIntersections_create_drop() { let obj = vtkBSPIntersections::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBSPIntersections(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkBezierCurve(*mut core::ffi::c_void); impl vtkBezierCurve { - /// Creates a new [vtkBezierCurve] wrapped inside `vtkNew` + /// Creates a new [vtkBezierCurve] via `vtkBezierCurve::New()` #[doc(alias = "vtkBezierCurve")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierCurve_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierCurve_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierCurve_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierCurve_get_ptr(self.0) } + Self(unsafe { vtkBezierCurve_new() }) } } impl std::default::Default for vtkBezierCurve { @@ -538,12 +37487,8 @@ impl Drop for vtkBezierCurve { #[test] fn test_vtkBezierCurve_create_drop() { let obj = vtkBezierCurve::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierCurve(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Bezier hex /// @@ -556,22 +37501,13 @@ fn test_vtkBezierCurve_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBezierHexahedron(*mut core::ffi::c_void); impl vtkBezierHexahedron { - /// Creates a new [vtkBezierHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkBezierHexahedron] via `vtkBezierHexahedron::New()` #[doc(alias = "vtkBezierHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierHexahedron_get_ptr(self.0) } + Self(unsafe { vtkBezierHexahedron_new() }) } } impl std::default::Default for vtkBezierHexahedron { @@ -591,33 +37527,20 @@ impl Drop for vtkBezierHexahedron { #[test] fn test_vtkBezierHexahedron_create_drop() { let obj = vtkBezierHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkBezierInterpolation(*mut core::ffi::c_void); impl vtkBezierInterpolation { - /// Creates a new [vtkBezierInterpolation] wrapped inside `vtkNew` + /// Creates a new [vtkBezierInterpolation] via `vtkBezierInterpolation::New()` #[doc(alias = "vtkBezierInterpolation")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierInterpolation_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierInterpolation_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierInterpolation_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierInterpolation_get_ptr(self.0) } + Self(unsafe { vtkBezierInterpolation_new() }) } } impl std::default::Default for vtkBezierInterpolation { @@ -637,33 +37560,20 @@ impl Drop for vtkBezierInterpolation { #[test] fn test_vtkBezierInterpolation_create_drop() { let obj = vtkBezierInterpolation::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierInterpolation(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkBezierQuadrilateral(*mut core::ffi::c_void); impl vtkBezierQuadrilateral { - /// Creates a new [vtkBezierQuadrilateral] wrapped inside `vtkNew` + /// Creates a new [vtkBezierQuadrilateral] via `vtkBezierQuadrilateral::New()` #[doc(alias = "vtkBezierQuadrilateral")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierQuadrilateral_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierQuadrilateral_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierQuadrilateral_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierQuadrilateral_get_ptr(self.0) } + Self(unsafe { vtkBezierQuadrilateral_new() }) } } impl std::default::Default for vtkBezierQuadrilateral { @@ -683,12 +37593,8 @@ impl Drop for vtkBezierQuadrilateral { #[test] fn test_vtkBezierQuadrilateral_create_drop() { let obj = vtkBezierQuadrilateral::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierQuadrilateral(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Bezier tetrahedron /// @@ -706,22 +37612,13 @@ fn test_vtkBezierQuadrilateral_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBezierTetra(*mut core::ffi::c_void); impl vtkBezierTetra { - /// Creates a new [vtkBezierTetra] wrapped inside `vtkNew` + /// Creates a new [vtkBezierTetra] via `vtkBezierTetra::New()` #[doc(alias = "vtkBezierTetra")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierTetra_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierTetra_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierTetra_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierTetra_get_ptr(self.0) } + Self(unsafe { vtkBezierTetra_new() }) } } impl std::default::Default for vtkBezierTetra { @@ -741,12 +37638,8 @@ impl Drop for vtkBezierTetra { #[test] fn test_vtkBezierTetra_create_drop() { let obj = vtkBezierTetra::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierTetra(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 2D cell that represents an arbitrary order Bezier triangle /// @@ -764,22 +37657,13 @@ fn test_vtkBezierTetra_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBezierTriangle(*mut core::ffi::c_void); impl vtkBezierTriangle { - /// Creates a new [vtkBezierTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkBezierTriangle] via `vtkBezierTriangle::New()` #[doc(alias = "vtkBezierTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierTriangle_get_ptr(self.0) } + Self(unsafe { vtkBezierTriangle_new() }) } } impl std::default::Default for vtkBezierTriangle { @@ -799,12 +37683,8 @@ impl Drop for vtkBezierTriangle { #[test] fn test_vtkBezierTriangle_create_drop() { let obj = vtkBezierTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Bezier wedge /// @@ -825,22 +37705,13 @@ fn test_vtkBezierTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBezierWedge(*mut core::ffi::c_void); impl vtkBezierWedge { - /// Creates a new [vtkBezierWedge] wrapped inside `vtkNew` + /// Creates a new [vtkBezierWedge] via `vtkBezierWedge::New()` #[doc(alias = "vtkBezierWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkBezierWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBezierWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBezierWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBezierWedge_get_ptr(self.0) } + Self(unsafe { vtkBezierWedge_new() }) } } impl std::default::Default for vtkBezierWedge { @@ -860,12 +37731,8 @@ impl Drop for vtkBezierWedge { #[test] fn test_vtkBezierWedge_create_drop() { let obj = vtkBezierWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBezierWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 9-node /// @@ -892,22 +37759,13 @@ fn test_vtkBezierWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBiQuadraticQuad(*mut core::ffi::c_void); impl vtkBiQuadraticQuad { - /// Creates a new [vtkBiQuadraticQuad] wrapped inside `vtkNew` + /// Creates a new [vtkBiQuadraticQuad] via `vtkBiQuadraticQuad::New()` #[doc(alias = "vtkBiQuadraticQuad")] pub fn new() -> Self { unsafe extern "C" { fn vtkBiQuadraticQuad_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBiQuadraticQuad_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBiQuadraticQuad_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBiQuadraticQuad_get_ptr(self.0) } + Self(unsafe { vtkBiQuadraticQuad_new() }) } } impl std::default::Default for vtkBiQuadraticQuad { @@ -927,12 +37785,8 @@ impl Drop for vtkBiQuadraticQuad { #[test] fn test_vtkBiQuadraticQuad_create_drop() { let obj = vtkBiQuadraticQuad::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBiQuadraticQuad(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a biquadratic, /// @@ -987,22 +37841,13 @@ fn test_vtkBiQuadraticQuad_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBiQuadraticQuadraticHexahedron(*mut core::ffi::c_void); impl vtkBiQuadraticQuadraticHexahedron { - /// Creates a new [vtkBiQuadraticQuadraticHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkBiQuadraticQuadraticHexahedron] via `vtkBiQuadraticQuadraticHexahedron::New()` #[doc(alias = "vtkBiQuadraticQuadraticHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkBiQuadraticQuadraticHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBiQuadraticQuadraticHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBiQuadraticQuadraticHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBiQuadraticQuadraticHexahedron_get_ptr(self.0) } + Self(unsafe { vtkBiQuadraticQuadraticHexahedron_new() }) } } impl std::default::Default for vtkBiQuadraticQuadraticHexahedron { @@ -1024,12 +37869,8 @@ impl Drop for vtkBiQuadraticQuadraticHexahedron { #[test] fn test_vtkBiQuadraticQuadraticHexahedron_create_drop() { let obj = vtkBiQuadraticQuadraticHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBiQuadraticQuadraticHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 18-node isoparametric wedge /// @@ -1057,22 +37898,13 @@ fn test_vtkBiQuadraticQuadraticHexahedron_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBiQuadraticQuadraticWedge(*mut core::ffi::c_void); impl vtkBiQuadraticQuadraticWedge { - /// Creates a new [vtkBiQuadraticQuadraticWedge] wrapped inside `vtkNew` + /// Creates a new [vtkBiQuadraticQuadraticWedge] via `vtkBiQuadraticQuadraticWedge::New()` #[doc(alias = "vtkBiQuadraticQuadraticWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkBiQuadraticQuadraticWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBiQuadraticQuadraticWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBiQuadraticQuadraticWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBiQuadraticQuadraticWedge_get_ptr(self.0) } + Self(unsafe { vtkBiQuadraticQuadraticWedge_new() }) } } impl std::default::Default for vtkBiQuadraticQuadraticWedge { @@ -1092,12 +37924,8 @@ impl Drop for vtkBiQuadraticQuadraticWedge { #[test] fn test_vtkBiQuadraticQuadraticWedge_create_drop() { let obj = vtkBiQuadraticQuadraticWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBiQuadraticQuadraticWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, isoparametric triangle /// @@ -1122,22 +37950,13 @@ fn test_vtkBiQuadraticQuadraticWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBiQuadraticTriangle(*mut core::ffi::c_void); impl vtkBiQuadraticTriangle { - /// Creates a new [vtkBiQuadraticTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkBiQuadraticTriangle] via `vtkBiQuadraticTriangle::New()` #[doc(alias = "vtkBiQuadraticTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkBiQuadraticTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBiQuadraticTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBiQuadraticTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkBiQuadraticTriangle_get_ptr(self.0) } + Self(unsafe { vtkBiQuadraticTriangle_new() }) } } impl std::default::Default for vtkBiQuadraticTriangle { @@ -1157,12 +37976,8 @@ impl Drop for vtkBiQuadraticTriangle { #[test] fn test_vtkBiQuadraticTriangle_create_drop() { let obj = vtkBiQuadraticTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBiQuadraticTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a bounding box /// @@ -1180,20 +37995,13 @@ fn test_vtkBiQuadraticTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkBox(*mut core::ffi::c_void); impl vtkBox { - /// Creates a new [vtkBox] wrapped inside `vtkNew` + /// Creates a new [vtkBox] via `vtkBox::New()` #[doc(alias = "vtkBox")] pub fn new() -> Self { unsafe extern "C" { fn vtkBox_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkBox_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkBox_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkBox_get_ptr(self.0) } + Self(unsafe { vtkBox_new() }) } } impl std::default::Default for vtkBox { @@ -1213,12 +38021,8 @@ impl Drop for vtkBox { #[test] fn test_vtkBox_create_drop() { let obj = vtkBox::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkBox(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// object to represent cell connectivity /// @@ -1254,7 +38058,7 @@ fn test_vtkBox_create_drop() { /// /// While this class provides traversal methods (the legacy InitTraversal(), /// GetNextCell() methods, and the newer method GetCellAtId()) these are in -/// general not thread-safe. Whenever possible it is preferable to use a +/// general not thread-safe. Whenever possible it is preferrable to use a /// local thread-safe, vtkCellArrayIterator object, which can be obtained via: /// /// ```cpp,ignore @@ -1340,22 +38144,13 @@ fn test_vtkBox_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellArray(*mut core::ffi::c_void); impl vtkCellArray { - /// Creates a new [vtkCellArray] wrapped inside `vtkNew` + /// Creates a new [vtkCellArray] via `vtkCellArray::New()` #[doc(alias = "vtkCellArray")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellArray_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellArray_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellArray_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellArray_get_ptr(self.0) } + Self(unsafe { vtkCellArray_new() }) } } impl std::default::Default for vtkCellArray { @@ -1375,12 +38170,8 @@ impl Drop for vtkCellArray { #[test] fn test_vtkCellArray_create_drop() { let obj = vtkCellArray::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellArray(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Encapsulate traversal logic for vtkCellArray. /// @@ -1431,22 +38222,13 @@ fn test_vtkCellArray_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellArrayIterator(*mut core::ffi::c_void); impl vtkCellArrayIterator { - /// Creates a new [vtkCellArrayIterator] wrapped inside `vtkNew` + /// Creates a new [vtkCellArrayIterator] via `vtkCellArrayIterator::New()` #[doc(alias = "vtkCellArrayIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellArrayIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellArrayIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellArrayIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellArrayIterator_get_ptr(self.0) } + Self(unsafe { vtkCellArrayIterator_new() }) } } impl std::default::Default for vtkCellArrayIterator { @@ -1466,12 +38248,8 @@ impl Drop for vtkCellArrayIterator { #[test] fn test_vtkCellArrayIterator_create_drop() { let obj = vtkCellArrayIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellArrayIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate cell attribute data /// @@ -1481,28 +38259,16 @@ fn test_vtkCellArrayIterator_create_drop() { /// coordinates, etc.) Special methods are provided to work with filter /// objects, such as passing data through filter, copying data from one /// cell to another, and interpolating data given cell interpolation weights. -/// -/// By default, `GhostTypesToSkip` is set to `DUPLICATECELL | HIDDENCELL | REFINEDCELL`. -/// See `vtkDataSetAttributes` for the definition of those constants. #[allow(non_camel_case_types)] pub struct vtkCellData(*mut core::ffi::c_void); impl vtkCellData { - /// Creates a new [vtkCellData] wrapped inside `vtkNew` + /// Creates a new [vtkCellData] via `vtkCellData::New()` #[doc(alias = "vtkCellData")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellData_get_ptr(self.0) } + Self(unsafe { vtkCellData_new() }) } } impl std::default::Default for vtkCellData { @@ -1522,12 +38288,8 @@ impl Drop for vtkCellData { #[test] fn test_vtkCellData_create_drop() { let obj = vtkCellData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// object represents upward pointers from points to list of cells using each point /// @@ -1550,22 +38312,13 @@ fn test_vtkCellData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellLinks(*mut core::ffi::c_void); impl vtkCellLinks { - /// Creates a new [vtkCellLinks] wrapped inside `vtkNew` + /// Creates a new [vtkCellLinks] via `vtkCellLinks::New()` #[doc(alias = "vtkCellLinks")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellLinks_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellLinks_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellLinks_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellLinks_get_ptr(self.0) } + Self(unsafe { vtkCellLinks_new() }) } } impl std::default::Default for vtkCellLinks { @@ -1585,12 +38338,8 @@ impl Drop for vtkCellLinks { #[test] fn test_vtkCellLinks_create_drop() { let obj = vtkCellLinks::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellLinks(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// octree-based spatial search object to quickly locate cells /// @@ -1605,39 +38354,27 @@ fn test_vtkCellLinks_create_drop() { /// candidate cells. /// /// @warning -/// vtkCellLocator utilizes the following parent class parameters: -/// - Automatic (default true) -/// - Level (default 8) -/// - MaxLevel (default 8) -/// - NumberOfCellsPerNode (default 25) -/// - CacheCellBounds (default true) -/// - UseExistingSearchStructure (default false) -/// -/// vtkCellLocator does NOT utilize the following parameters: -/// - Tolerance -/// - RetainCellLists +/// Many other types of spatial locators have been developed, such as +/// variable depth octrees and kd-trees. These are often more efficient +/// for the operations described here. vtkCellLocator has been designed +/// for subclassing; so these locators can be derived if necessary. +/// +/// @warning +/// Most of the methods of this class are not thread-safe. For a thread-safe, +/// more efficient generic implementation, please use vtkStaticCellLocator /// /// @sa -/// vtkAbstractCellLocator vtkStaticCellLocator vtkCellTreeLocator vtkModifiedBSPTree vtkOBBTree +/// vtkLocator vtkPointLocator vtkOBBTree vtkStaticCellLocator #[allow(non_camel_case_types)] pub struct vtkCellLocator(*mut core::ffi::c_void); impl vtkCellLocator { - /// Creates a new [vtkCellLocator] wrapped inside `vtkNew` + /// Creates a new [vtkCellLocator] via `vtkCellLocator::New()` #[doc(alias = "vtkCellLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellLocator_get_ptr(self.0) } + Self(unsafe { vtkCellLocator_new() }) } } impl std::default::Default for vtkCellLocator { @@ -1657,12 +38394,8 @@ impl Drop for vtkCellLocator { #[test] fn test_vtkCellLocator_create_drop() { let obj = vtkCellLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implement a specific vtkPointSet::FindCell() strategy based /// @@ -1677,22 +38410,13 @@ fn test_vtkCellLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellLocatorStrategy(*mut core::ffi::c_void); impl vtkCellLocatorStrategy { - /// Creates a new [vtkCellLocatorStrategy] wrapped inside `vtkNew` + /// Creates a new [vtkCellLocatorStrategy] via `vtkCellLocatorStrategy::New()` #[doc(alias = "vtkCellLocatorStrategy")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellLocatorStrategy_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellLocatorStrategy_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellLocatorStrategy_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellLocatorStrategy_get_ptr(self.0) } + Self(unsafe { vtkCellLocatorStrategy_new() }) } } impl std::default::Default for vtkCellLocatorStrategy { @@ -1712,90 +38436,8 @@ impl Drop for vtkCellLocatorStrategy { #[test] fn test_vtkCellLocatorStrategy_create_drop() { let obj = vtkCellLocatorStrategy::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); - drop(obj); - let new_obj = vtkCellLocatorStrategy(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); -} -/// This class implements the data structures, construction -/// -/// algorithms for fast cell location. -/// -/// Cell Tree is a bounding interval hierarchy based data structure, where child boxes -/// do not form an exact split of the parent boxes along a dimension. Therefore two axis- -/// aligned bounding planes (left max and right min) are stored for each node along a -/// dimension. This class implements the data structure (Cell Tree Node) and its build -/// and traversal algorithms described in the paper. -/// Some methods in building and traversing the cell tree in this class were derived -/// from avtCellLocatorBIH class in the VisIT Visualization Tool. -/// -/// vtkCellTreeLocator utilizes the following parent class parameters: -/// - NumberOfCellsPerNode (default 8) -/// - CacheCellBounds (default true) -/// - UseExistingSearchStructure (default false) -/// -/// vtkCellTreeLocator does NOT utilize the following parameters: -/// - Automatic -/// - Level -/// - MaxLevel -/// - Tolerance -/// - RetainCellLists -/// -/// @warning -/// This class is templated. It may run slower than serial execution if the code -/// is not optimized during compilation. Build in Release or ReleaseWithDebugInfo. -/// -/// From the article: "Fast, Memory-Efficient Cell location in Unstructured Grids for Visualization" -/// by Christoph Garth and Kenneth I. Joy in VisWeek, 2011. -/// -/// @sa -/// vtkAbstractCellLocator vtkCellLocator vtkStaticCellLocator vtkModifiedBSPTree vtkOBBTree -#[allow(non_camel_case_types)] -pub struct vtkCellTreeLocator(*mut core::ffi::c_void); -impl vtkCellTreeLocator { - /// Creates a new [vtkCellTreeLocator] wrapped inside `vtkNew` - #[doc(alias = "vtkCellTreeLocator")] - pub fn new() -> Self { - unsafe extern "C" { - fn vtkCellTreeLocator_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkCellTreeLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellTreeLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellTreeLocator_get_ptr(self.0) } - } -} -impl std::default::Default for vtkCellTreeLocator { - fn default() -> Self { - Self::new() - } -} -impl Drop for vtkCellTreeLocator { - fn drop(&mut self) { - unsafe extern "C" { - fn vtkCellTreeLocator_destructor(sself: *mut core::ffi::c_void); - } - unsafe { vtkCellTreeLocator_destructor(self.0) } - self.0 = core::ptr::null_mut(); - } -} -#[test] -fn test_vtkCellTreeLocator_create_drop() { - let obj = vtkCellTreeLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellTreeLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// object provides direct access to cells in vtkCellArray and type information /// @@ -1818,22 +38460,13 @@ fn test_vtkCellTreeLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCellTypes(*mut core::ffi::c_void); impl vtkCellTypes { - /// Creates a new [vtkCellTypes] wrapped inside `vtkNew` + /// Creates a new [vtkCellTypes] via `vtkCellTypes::New()` #[doc(alias = "vtkCellTypes")] pub fn new() -> Self { unsafe extern "C" { fn vtkCellTypes_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCellTypes_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCellTypes_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCellTypes_get_ptr(self.0) } + Self(unsafe { vtkCellTypes_new() }) } } impl std::default::Default for vtkCellTypes { @@ -1853,12 +38486,8 @@ impl Drop for vtkCellTypes { #[test] fn test_vtkCellTypes_create_drop() { let obj = vtkCellTypes::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCellTypes(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implement a specific vtkPointSet::FindCell() strategy based /// @@ -1874,22 +38503,13 @@ fn test_vtkCellTypes_create_drop() { #[allow(non_camel_case_types)] pub struct vtkClosestNPointsStrategy(*mut core::ffi::c_void); impl vtkClosestNPointsStrategy { - /// Creates a new [vtkClosestNPointsStrategy] wrapped inside `vtkNew` + /// Creates a new [vtkClosestNPointsStrategy] via `vtkClosestNPointsStrategy::New()` #[doc(alias = "vtkClosestNPointsStrategy")] pub fn new() -> Self { unsafe extern "C" { fn vtkClosestNPointsStrategy_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkClosestNPointsStrategy_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkClosestNPointsStrategy_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkClosestNPointsStrategy_get_ptr(self.0) } + Self(unsafe { vtkClosestNPointsStrategy_new() }) } } impl std::default::Default for vtkClosestNPointsStrategy { @@ -1909,12 +38529,8 @@ impl Drop for vtkClosestNPointsStrategy { #[test] fn test_vtkClosestNPointsStrategy_create_drop() { let obj = vtkClosestNPointsStrategy::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkClosestNPointsStrategy(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implement a specific vtkPointSet::FindCell() strategy based /// @@ -1933,22 +38549,13 @@ fn test_vtkClosestNPointsStrategy_create_drop() { #[allow(non_camel_case_types)] pub struct vtkClosestPointStrategy(*mut core::ffi::c_void); impl vtkClosestPointStrategy { - /// Creates a new [vtkClosestPointStrategy] wrapped inside `vtkNew` + /// Creates a new [vtkClosestPointStrategy] via `vtkClosestPointStrategy::New()` #[doc(alias = "vtkClosestPointStrategy")] pub fn new() -> Self { unsafe extern "C" { fn vtkClosestPointStrategy_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkClosestPointStrategy_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkClosestPointStrategy_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkClosestPointStrategy_get_ptr(self.0) } + Self(unsafe { vtkClosestPointStrategy_new() }) } } impl std::default::Default for vtkClosestPointStrategy { @@ -1968,12 +38575,8 @@ impl Drop for vtkClosestPointStrategy { #[test] fn test_vtkClosestPointStrategy_create_drop() { let obj = vtkClosestPointStrategy::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkClosestPointStrategy(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a cone /// @@ -1991,20 +38594,13 @@ fn test_vtkClosestPointStrategy_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCone(*mut core::ffi::c_void); impl vtkCone { - /// Creates a new [vtkCone] wrapped inside `vtkNew` + /// Creates a new [vtkCone] via `vtkCone::New()` #[doc(alias = "vtkCone")] pub fn new() -> Self { unsafe extern "C" { fn vtkCone_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCone_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCone_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkCone_get_ptr(self.0) } + Self(unsafe { vtkCone_new() }) } } impl std::default::Default for vtkCone { @@ -2024,12 +38620,8 @@ impl Drop for vtkCone { #[test] fn test_vtkCone_create_drop() { let obj = vtkCone::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCone(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell defined by a set of convex points /// @@ -2046,22 +38638,13 @@ fn test_vtkCone_create_drop() { #[allow(non_camel_case_types)] pub struct vtkConvexPointSet(*mut core::ffi::c_void); impl vtkConvexPointSet { - /// Creates a new [vtkConvexPointSet] wrapped inside `vtkNew` + /// Creates a new [vtkConvexPointSet] via `vtkConvexPointSet::New()` #[doc(alias = "vtkConvexPointSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkConvexPointSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkConvexPointSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkConvexPointSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkConvexPointSet_get_ptr(self.0) } + Self(unsafe { vtkConvexPointSet_new() }) } } impl std::default::Default for vtkConvexPointSet { @@ -2081,75 +38664,8 @@ impl Drop for vtkConvexPointSet { #[test] fn test_vtkConvexPointSet_create_drop() { let obj = vtkConvexPointSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); - drop(obj); - let new_obj = vtkConvexPointSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); -} -/// implicit function for a right-handed coordinate system -/// -/// -/// vtkCoordinateFrame computes an implicit function and function gradient -/// for a set of 3 orthogonal planes. -/// -/// The function evaluates to a combination of quartic spherical harmonic -/// basis functions: -/// \f$\sqrt(\frac{7}{12})*Y_{4,0} + \sqrt(\frac{5}{12})*Y_{4,4}\f$ -/// that – when evaluated on a unit sphere centered at the coordinate frame's -/// origin – form a 6-lobed function with a maximum along each of the -/// 6 axes (3 positive, 3 negative). -/// This function is frequently used in frame-field design. -/// -/// See the paper "On Smooth Frame Field Design" by Nicolas Ray and -/// Dmitry Sokolov (2016, hal-01245657, -/// https://hal.inria.fr/hal-01245657/file/framefield.pdf ) for more -/// information. -#[allow(non_camel_case_types)] -pub struct vtkCoordinateFrame(*mut core::ffi::c_void); -impl vtkCoordinateFrame { - /// Creates a new [vtkCoordinateFrame] wrapped inside `vtkNew` - #[doc(alias = "vtkCoordinateFrame")] - pub fn new() -> Self { - unsafe extern "C" { - fn vtkCoordinateFrame_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkCoordinateFrame_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCoordinateFrame_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCoordinateFrame_get_ptr(self.0) } - } -} -impl std::default::Default for vtkCoordinateFrame { - fn default() -> Self { - Self::new() - } -} -impl Drop for vtkCoordinateFrame { - fn drop(&mut self) { - unsafe extern "C" { - fn vtkCoordinateFrame_destructor(sself: *mut core::ffi::c_void); - } - unsafe { vtkCoordinateFrame_destructor(self.0) } - self.0 = core::ptr::null_mut(); - } -} -#[test] -fn test_vtkCoordinateFrame_create_drop() { - let obj = vtkCoordinateFrame::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCoordinateFrame(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a cubic , isoparametric 1D line /// @@ -2169,22 +38685,13 @@ fn test_vtkCoordinateFrame_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCubicLine(*mut core::ffi::c_void); impl vtkCubicLine { - /// Creates a new [vtkCubicLine] wrapped inside `vtkNew` + /// Creates a new [vtkCubicLine] via `vtkCubicLine::New()` #[doc(alias = "vtkCubicLine")] pub fn new() -> Self { unsafe extern "C" { fn vtkCubicLine_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCubicLine_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCubicLine_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCubicLine_get_ptr(self.0) } + Self(unsafe { vtkCubicLine_new() }) } } impl std::default::Default for vtkCubicLine { @@ -2204,12 +38711,8 @@ impl Drop for vtkCubicLine { #[test] fn test_vtkCubicLine_create_drop() { let obj = vtkCubicLine::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCubicLine(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a cylinder /// @@ -2228,28 +38731,16 @@ fn test_vtkCubicLine_create_drop() { /// The cylinder is infinite in extent. To truncate the cylinder in /// modeling operations use the vtkImplicitBoolean in combination with /// clipping planes. -/// -/// @sa -/// vtkCylinderSource #[allow(non_camel_case_types)] pub struct vtkCylinder(*mut core::ffi::c_void); impl vtkCylinder { - /// Creates a new [vtkCylinder] wrapped inside `vtkNew` + /// Creates a new [vtkCylinder] via `vtkCylinder::New()` #[doc(alias = "vtkCylinder")] pub fn new() -> Self { unsafe extern "C" { fn vtkCylinder_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCylinder_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCylinder_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCylinder_get_ptr(self.0) } + Self(unsafe { vtkCylinder_new() }) } } impl std::default::Default for vtkCylinder { @@ -2269,12 +38760,8 @@ impl Drop for vtkCylinder { #[test] fn test_vtkCylinder_create_drop() { let obj = vtkCylinder::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCylinder(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// hierarchical representation to use with /// @@ -2354,11 +38841,11 @@ fn test_vtkCylinder_create_drop() { /// nodes rather than the nodes themselves. /// /// * '/nodename1/nodename2' selects all nodes named 'nodename2' which are -/// children of nodes with name 'nodename1' that are themselves children of -/// the root node. +/// childen of nodes with name 'nodename1' that are themselves children of the +/// root node. /// /// * '//nodename1/nodename2' finds all nodes in the tree named 'nodename1' and -/// then selects all children of these found nodes that are named 'nodename2'. +/// then selects all chidren of these found nodes that are named 'nodename2'. /// /// @section Applications Applications /// @@ -2377,22 +38864,13 @@ fn test_vtkCylinder_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataAssembly(*mut core::ffi::c_void); impl vtkDataAssembly { - /// Creates a new [vtkDataAssembly] wrapped inside `vtkNew` + /// Creates a new [vtkDataAssembly] via `vtkDataAssembly::New()` #[doc(alias = "vtkDataAssembly")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataAssembly_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataAssembly_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataAssembly_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataAssembly_get_ptr(self.0) } + Self(unsafe { vtkDataAssembly_new() }) } } impl std::default::Default for vtkDataAssembly { @@ -2412,12 +38890,8 @@ impl Drop for vtkDataAssembly { #[test] fn test_vtkDataAssembly_create_drop() { let obj = vtkDataAssembly::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataAssembly(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// collections of utilities for vtkDataAssembly /// @@ -2427,22 +38901,13 @@ fn test_vtkDataAssembly_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataAssemblyUtilities(*mut core::ffi::c_void); impl vtkDataAssemblyUtilities { - /// Creates a new [vtkDataAssemblyUtilities] wrapped inside `vtkNew` + /// Creates a new [vtkDataAssemblyUtilities] via `vtkDataAssemblyUtilities::New()` #[doc(alias = "vtkDataAssemblyUtilities")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataAssemblyUtilities_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataAssemblyUtilities_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataAssemblyUtilities_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataAssemblyUtilities_get_ptr(self.0) } + Self(unsafe { vtkDataAssemblyUtilities_new() }) } } impl std::default::Default for vtkDataAssemblyUtilities { @@ -2462,12 +38927,8 @@ impl Drop for vtkDataAssemblyUtilities { #[test] fn test_vtkDataAssemblyUtilities_create_drop() { let obj = vtkDataAssemblyUtilities::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataAssemblyUtilities(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// general representation of visualization data /// @@ -2488,22 +38949,13 @@ fn test_vtkDataAssemblyUtilities_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataObject(*mut core::ffi::c_void); impl vtkDataObject { - /// Creates a new [vtkDataObject] wrapped inside `vtkNew` + /// Creates a new [vtkDataObject] via `vtkDataObject::New()` #[doc(alias = "vtkDataObject")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObject_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObject_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObject_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObject_get_ptr(self.0) } + Self(unsafe { vtkDataObject_new() }) } } impl std::default::Default for vtkDataObject { @@ -2523,12 +38975,8 @@ impl Drop for vtkDataObject { #[test] fn test_vtkDataObject_create_drop() { let obj = vtkDataObject::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObject(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain an unordered list of data objects /// @@ -2538,22 +38986,13 @@ fn test_vtkDataObject_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataObjectCollection(*mut core::ffi::c_void); impl vtkDataObjectCollection { - /// Creates a new [vtkDataObjectCollection] wrapped inside `vtkNew` + /// Creates a new [vtkDataObjectCollection] via `vtkDataObjectCollection::New()` #[doc(alias = "vtkDataObjectCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObjectCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObjectCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObjectCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObjectCollection_get_ptr(self.0) } + Self(unsafe { vtkDataObjectCollection_new() }) } } impl std::default::Default for vtkDataObjectCollection { @@ -2573,12 +39012,8 @@ impl Drop for vtkDataObjectCollection { #[test] fn test_vtkDataObjectCollection_create_drop() { let obj = vtkDataObjectCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObjectCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// superclass for composite data iterators /// @@ -2588,22 +39023,13 @@ fn test_vtkDataObjectCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataObjectTreeIterator(*mut core::ffi::c_void); impl vtkDataObjectTreeIterator { - /// Creates a new [vtkDataObjectTreeIterator] wrapped inside `vtkNew` + /// Creates a new [vtkDataObjectTreeIterator] via `vtkDataObjectTreeIterator::New()` #[doc(alias = "vtkDataObjectTreeIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObjectTreeIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObjectTreeIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObjectTreeIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObjectTreeIterator_get_ptr(self.0) } + Self(unsafe { vtkDataObjectTreeIterator_new() }) } } impl std::default::Default for vtkDataObjectTreeIterator { @@ -2623,33 +39049,20 @@ impl Drop for vtkDataObjectTreeIterator { #[test] fn test_vtkDataObjectTreeIterator_create_drop() { let obj = vtkDataObjectTreeIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObjectTreeIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkDataObjectTypes(*mut core::ffi::c_void); impl vtkDataObjectTypes { - /// Creates a new [vtkDataObjectTypes] wrapped inside `vtkNew` + /// Creates a new [vtkDataObjectTypes] via `vtkDataObjectTypes::New()` #[doc(alias = "vtkDataObjectTypes")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObjectTypes_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObjectTypes_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObjectTypes_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObjectTypes_get_ptr(self.0) } + Self(unsafe { vtkDataObjectTypes_new() }) } } impl std::default::Default for vtkDataObjectTypes { @@ -2669,12 +39082,8 @@ impl Drop for vtkDataObjectTypes { #[test] fn test_vtkDataObjectTypes_create_drop() { let obj = vtkDataObjectTypes::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObjectTypes(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate attribute data in a dataset /// @@ -2712,22 +39121,13 @@ fn test_vtkDataObjectTypes_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataSetAttributes(*mut core::ffi::c_void); impl vtkDataSetAttributes { - /// Creates a new [vtkDataSetAttributes] wrapped inside `vtkNew` + /// Creates a new [vtkDataSetAttributes] via `vtkDataSetAttributes::New()` #[doc(alias = "vtkDataSetAttributes")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataSetAttributes_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataSetAttributes_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataSetAttributes_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataSetAttributes_get_ptr(self.0) } + Self(unsafe { vtkDataSetAttributes_new() }) } } impl std::default::Default for vtkDataSetAttributes { @@ -2747,12 +39147,8 @@ impl Drop for vtkDataSetAttributes { #[test] fn test_vtkDataSetAttributes_create_drop() { let obj = vtkDataSetAttributes::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataSetAttributes(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implementation of vtkCellIterator using /// @@ -2760,22 +39156,13 @@ fn test_vtkDataSetAttributes_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataSetCellIterator(*mut core::ffi::c_void); impl vtkDataSetCellIterator { - /// Creates a new [vtkDataSetCellIterator] wrapped inside `vtkNew` + /// Creates a new [vtkDataSetCellIterator] via `vtkDataSetCellIterator::New()` #[doc(alias = "vtkDataSetCellIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataSetCellIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataSetCellIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataSetCellIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataSetCellIterator_get_ptr(self.0) } + Self(unsafe { vtkDataSetCellIterator_new() }) } } impl std::default::Default for vtkDataSetCellIterator { @@ -2795,12 +39182,8 @@ impl Drop for vtkDataSetCellIterator { #[test] fn test_vtkDataSetCellIterator_create_drop() { let obj = vtkDataSetCellIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataSetCellIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain an unordered list of dataset objects /// @@ -2810,22 +39193,13 @@ fn test_vtkDataSetCellIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataSetCollection(*mut core::ffi::c_void); impl vtkDataSetCollection { - /// Creates a new [vtkDataSetCollection] wrapped inside `vtkNew` + /// Creates a new [vtkDataSetCollection] via `vtkDataSetCollection::New()` #[doc(alias = "vtkDataSetCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataSetCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataSetCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataSetCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataSetCollection_get_ptr(self.0) } + Self(unsafe { vtkDataSetCollection_new() }) } } impl std::default::Default for vtkDataSetCollection { @@ -2845,12 +39219,8 @@ impl Drop for vtkDataSetCollection { #[test] fn test_vtkDataSetCollection_create_drop() { let obj = vtkDataSetCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataSetCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A rooted tree data structure. /// @@ -2878,22 +39248,13 @@ fn test_vtkDataSetCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDirectedAcyclicGraph(*mut core::ffi::c_void); impl vtkDirectedAcyclicGraph { - /// Creates a new [vtkDirectedAcyclicGraph] wrapped inside `vtkNew` + /// Creates a new [vtkDirectedAcyclicGraph] via `vtkDirectedAcyclicGraph::New()` #[doc(alias = "vtkDirectedAcyclicGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkDirectedAcyclicGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDirectedAcyclicGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDirectedAcyclicGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDirectedAcyclicGraph_get_ptr(self.0) } + Self(unsafe { vtkDirectedAcyclicGraph_new() }) } } impl std::default::Default for vtkDirectedAcyclicGraph { @@ -2913,12 +39274,8 @@ impl Drop for vtkDirectedAcyclicGraph { #[test] fn test_vtkDirectedAcyclicGraph_create_drop() { let obj = vtkDirectedAcyclicGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDirectedAcyclicGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A directed graph. /// @@ -2938,22 +39295,13 @@ fn test_vtkDirectedAcyclicGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDirectedGraph(*mut core::ffi::c_void); impl vtkDirectedGraph { - /// Creates a new [vtkDirectedGraph] wrapped inside `vtkNew` + /// Creates a new [vtkDirectedGraph] via `vtkDirectedGraph::New()` #[doc(alias = "vtkDirectedGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkDirectedGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDirectedGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDirectedGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDirectedGraph_get_ptr(self.0) } + Self(unsafe { vtkDirectedGraph_new() }) } } impl std::default::Default for vtkDirectedGraph { @@ -2973,12 +39321,8 @@ impl Drop for vtkDirectedGraph { #[test] fn test_vtkDirectedGraph_create_drop() { let obj = vtkDirectedGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDirectedGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates through all edges in a graph. /// @@ -2998,22 +39342,13 @@ fn test_vtkDirectedGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEdgeListIterator(*mut core::ffi::c_void); impl vtkEdgeListIterator { - /// Creates a new [vtkEdgeListIterator] wrapped inside `vtkNew` + /// Creates a new [vtkEdgeListIterator] via `vtkEdgeListIterator::New()` #[doc(alias = "vtkEdgeListIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkEdgeListIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEdgeListIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEdgeListIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEdgeListIterator_get_ptr(self.0) } + Self(unsafe { vtkEdgeListIterator_new() }) } } impl std::default::Default for vtkEdgeListIterator { @@ -3033,12 +39368,8 @@ impl Drop for vtkEdgeListIterator { #[test] fn test_vtkEdgeListIterator_create_drop() { let obj = vtkEdgeListIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEdgeListIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// keep track of edges (edge is pair of integer id's) /// @@ -3055,22 +39386,13 @@ fn test_vtkEdgeListIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEdgeTable(*mut core::ffi::c_void); impl vtkEdgeTable { - /// Creates a new [vtkEdgeTable] wrapped inside `vtkNew` + /// Creates a new [vtkEdgeTable] via `vtkEdgeTable::New()` #[doc(alias = "vtkEdgeTable")] pub fn new() -> Self { unsafe extern "C" { fn vtkEdgeTable_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEdgeTable_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEdgeTable_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEdgeTable_get_ptr(self.0) } + Self(unsafe { vtkEdgeTable_new() }) } } impl std::default::Default for vtkEdgeTable { @@ -3090,12 +39412,8 @@ impl Drop for vtkEdgeTable { #[test] fn test_vtkEdgeTable_create_drop() { let obj = vtkEdgeTable::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEdgeTable(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// an empty cell used as a place-holder during processing /// @@ -3105,22 +39423,13 @@ fn test_vtkEdgeTable_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEmptyCell(*mut core::ffi::c_void); impl vtkEmptyCell { - /// Creates a new [vtkEmptyCell] wrapped inside `vtkNew` + /// Creates a new [vtkEmptyCell] via `vtkEmptyCell::New()` #[doc(alias = "vtkEmptyCell")] pub fn new() -> Self { unsafe extern "C" { fn vtkEmptyCell_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEmptyCell_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEmptyCell_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEmptyCell_get_ptr(self.0) } + Self(unsafe { vtkEmptyCell_new() }) } } impl std::default::Default for vtkEmptyCell { @@ -3140,12 +39449,8 @@ impl Drop for vtkEmptyCell { #[test] fn test_vtkEmptyCell_create_drop() { let obj = vtkEmptyCell::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEmptyCell(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// structured grid with explicit topology and geometry /// @@ -3186,22 +39491,13 @@ fn test_vtkEmptyCell_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExplicitStructuredGrid(*mut core::ffi::c_void); impl vtkExplicitStructuredGrid { - /// Creates a new [vtkExplicitStructuredGrid] wrapped inside `vtkNew` + /// Creates a new [vtkExplicitStructuredGrid] via `vtkExplicitStructuredGrid::New()` #[doc(alias = "vtkExplicitStructuredGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkExplicitStructuredGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExplicitStructuredGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExplicitStructuredGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExplicitStructuredGrid_get_ptr(self.0) } + Self(unsafe { vtkExplicitStructuredGrid_new() }) } } impl std::default::Default for vtkExplicitStructuredGrid { @@ -3221,12 +39517,8 @@ impl Drop for vtkExplicitStructuredGrid { #[test] fn test_vtkExplicitStructuredGrid_create_drop() { let obj = vtkExplicitStructuredGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExplicitStructuredGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper for extracting/sub-sampling /// @@ -3243,22 +39535,13 @@ fn test_vtkExplicitStructuredGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExtractStructuredGridHelper(*mut core::ffi::c_void); impl vtkExtractStructuredGridHelper { - /// Creates a new [vtkExtractStructuredGridHelper] wrapped inside `vtkNew` + /// Creates a new [vtkExtractStructuredGridHelper] via `vtkExtractStructuredGridHelper::New()` #[doc(alias = "vtkExtractStructuredGridHelper")] pub fn new() -> Self { unsafe extern "C" { fn vtkExtractStructuredGridHelper_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExtractStructuredGridHelper_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExtractStructuredGridHelper_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExtractStructuredGridHelper_get_ptr(self.0) } + Self(unsafe { vtkExtractStructuredGridHelper_new() }) } } impl std::default::Default for vtkExtractStructuredGridHelper { @@ -3278,12 +39561,8 @@ impl Drop for vtkExtractStructuredGridHelper { #[test] fn test_vtkExtractStructuredGridHelper_create_drop() { let obj = vtkExtractStructuredGridHelper::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExtractStructuredGridHelper(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate fields of data /// @@ -3313,22 +39592,13 @@ fn test_vtkExtractStructuredGridHelper_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFieldData(*mut core::ffi::c_void); impl vtkFieldData { - /// Creates a new [vtkFieldData] wrapped inside `vtkNew` + /// Creates a new [vtkFieldData] via `vtkFieldData::New()` #[doc(alias = "vtkFieldData")] pub fn new() -> Self { unsafe extern "C" { fn vtkFieldData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFieldData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFieldData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkFieldData_get_ptr(self.0) } + Self(unsafe { vtkFieldData_new() }) } } impl std::default::Default for vtkFieldData { @@ -3348,12 +39618,8 @@ impl Drop for vtkFieldData { #[test] fn test_vtkFieldData_create_drop() { let obj = vtkFieldData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFieldData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a collection of attributes /// @@ -3363,22 +39629,13 @@ fn test_vtkFieldData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGenericAttributeCollection(*mut core::ffi::c_void); impl vtkGenericAttributeCollection { - /// Creates a new [vtkGenericAttributeCollection] wrapped inside `vtkNew` + /// Creates a new [vtkGenericAttributeCollection] via `vtkGenericAttributeCollection::New()` #[doc(alias = "vtkGenericAttributeCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkGenericAttributeCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGenericAttributeCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGenericAttributeCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGenericAttributeCollection_get_ptr(self.0) } + Self(unsafe { vtkGenericAttributeCollection_new() }) } } impl std::default::Default for vtkGenericAttributeCollection { @@ -3398,12 +39655,8 @@ impl Drop for vtkGenericAttributeCollection { #[test] fn test_vtkGenericAttributeCollection_create_drop() { let obj = vtkGenericAttributeCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGenericAttributeCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// provides thread-safe access to cells /// @@ -3420,22 +39673,13 @@ fn test_vtkGenericAttributeCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGenericCell(*mut core::ffi::c_void); impl vtkGenericCell { - /// Creates a new [vtkGenericCell] wrapped inside `vtkNew` + /// Creates a new [vtkGenericCell] via `vtkGenericCell::New()` #[doc(alias = "vtkGenericCell")] pub fn new() -> Self { unsafe extern "C" { fn vtkGenericCell_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGenericCell_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGenericCell_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGenericCell_get_ptr(self.0) } + Self(unsafe { vtkGenericCell_new() }) } } impl std::default::Default for vtkGenericCell { @@ -3455,12 +39699,8 @@ impl Drop for vtkGenericCell { #[test] fn test_vtkGenericCell_create_drop() { let obj = vtkGenericCell::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGenericCell(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// keep track of edges (defined by pair of integer id's) /// @@ -3477,22 +39717,13 @@ fn test_vtkGenericCell_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGenericEdgeTable(*mut core::ffi::c_void); impl vtkGenericEdgeTable { - /// Creates a new [vtkGenericEdgeTable] wrapped inside `vtkNew` + /// Creates a new [vtkGenericEdgeTable] via `vtkGenericEdgeTable::New()` #[doc(alias = "vtkGenericEdgeTable")] pub fn new() -> Self { unsafe extern "C" { fn vtkGenericEdgeTable_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGenericEdgeTable_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGenericEdgeTable_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGenericEdgeTable_get_ptr(self.0) } + Self(unsafe { vtkGenericEdgeTable_new() }) } } impl std::default::Default for vtkGenericEdgeTable { @@ -3512,12 +39743,8 @@ impl Drop for vtkGenericEdgeTable { #[test] fn test_vtkGenericEdgeTable_create_drop() { let obj = vtkGenericEdgeTable::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGenericEdgeTable(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Interface for obtaining /// @@ -3546,22 +39773,13 @@ fn test_vtkGenericEdgeTable_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGenericInterpolatedVelocityField(*mut core::ffi::c_void); impl vtkGenericInterpolatedVelocityField { - /// Creates a new [vtkGenericInterpolatedVelocityField] wrapped inside `vtkNew` + /// Creates a new [vtkGenericInterpolatedVelocityField] via `vtkGenericInterpolatedVelocityField::New()` #[doc(alias = "vtkGenericInterpolatedVelocityField")] pub fn new() -> Self { unsafe extern "C" { fn vtkGenericInterpolatedVelocityField_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGenericInterpolatedVelocityField_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGenericInterpolatedVelocityField_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGenericInterpolatedVelocityField_get_ptr(self.0) } + Self(unsafe { vtkGenericInterpolatedVelocityField_new() }) } } impl std::default::Default for vtkGenericInterpolatedVelocityField { @@ -3583,12 +39801,8 @@ impl Drop for vtkGenericInterpolatedVelocityField { #[test] fn test_vtkGenericInterpolatedVelocityField_create_drop() { let obj = vtkGenericInterpolatedVelocityField::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGenericInterpolatedVelocityField(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects that compute /// @@ -3603,22 +39817,13 @@ fn test_vtkGenericInterpolatedVelocityField_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGeometricErrorMetric(*mut core::ffi::c_void); impl vtkGeometricErrorMetric { - /// Creates a new [vtkGeometricErrorMetric] wrapped inside `vtkNew` + /// Creates a new [vtkGeometricErrorMetric] via `vtkGeometricErrorMetric::New()` #[doc(alias = "vtkGeometricErrorMetric")] pub fn new() -> Self { unsafe extern "C" { fn vtkGeometricErrorMetric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGeometricErrorMetric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGeometricErrorMetric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGeometricErrorMetric_get_ptr(self.0) } + Self(unsafe { vtkGeometricErrorMetric_new() }) } } impl std::default::Default for vtkGeometricErrorMetric { @@ -3638,12 +39843,8 @@ impl Drop for vtkGeometricErrorMetric { #[test] fn test_vtkGeometricErrorMetric_create_drop() { let obj = vtkGeometricErrorMetric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGeometricErrorMetric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Representation of a single graph edge. /// @@ -3658,22 +39859,13 @@ fn test_vtkGeometricErrorMetric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGraphEdge(*mut core::ffi::c_void); impl vtkGraphEdge { - /// Creates a new [vtkGraphEdge] wrapped inside `vtkNew` + /// Creates a new [vtkGraphEdge] via `vtkGraphEdge::New()` #[doc(alias = "vtkGraphEdge")] pub fn new() -> Self { unsafe extern "C" { fn vtkGraphEdge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGraphEdge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGraphEdge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGraphEdge_get_ptr(self.0) } + Self(unsafe { vtkGraphEdge_new() }) } } impl std::default::Default for vtkGraphEdge { @@ -3693,12 +39885,8 @@ impl Drop for vtkGraphEdge { #[test] fn test_vtkGraphEdge_create_drop() { let obj = vtkGraphEdge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGraphEdge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Internal representation of vtkGraph /// @@ -3709,22 +39897,13 @@ fn test_vtkGraphEdge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGraphInternals(*mut core::ffi::c_void); impl vtkGraphInternals { - /// Creates a new [vtkGraphInternals] wrapped inside `vtkNew` + /// Creates a new [vtkGraphInternals] via `vtkGraphInternals::New()` #[doc(alias = "vtkGraphInternals")] pub fn new() -> Self { unsafe extern "C" { fn vtkGraphInternals_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGraphInternals_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGraphInternals_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGraphInternals_get_ptr(self.0) } + Self(unsafe { vtkGraphInternals_new() }) } } impl std::default::Default for vtkGraphInternals { @@ -3744,12 +39923,8 @@ impl Drop for vtkGraphInternals { #[test] fn test_vtkGraphInternals_create_drop() { let obj = vtkGraphInternals::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGraphInternals(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a prism with /// @@ -3771,22 +39946,13 @@ fn test_vtkGraphInternals_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHexagonalPrism(*mut core::ffi::c_void); impl vtkHexagonalPrism { - /// Creates a new [vtkHexagonalPrism] wrapped inside `vtkNew` + /// Creates a new [vtkHexagonalPrism] via `vtkHexagonalPrism::New()` #[doc(alias = "vtkHexagonalPrism")] pub fn new() -> Self { unsafe extern "C" { fn vtkHexagonalPrism_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHexagonalPrism_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHexagonalPrism_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHexagonalPrism_get_ptr(self.0) } + Self(unsafe { vtkHexagonalPrism_new() }) } } impl std::default::Default for vtkHexagonalPrism { @@ -3806,12 +39972,8 @@ impl Drop for vtkHexagonalPrism { #[test] fn test_vtkHexagonalPrism_create_drop() { let obj = vtkHexagonalPrism::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHexagonalPrism(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a linear 3D hexahedron /// @@ -3829,22 +39991,13 @@ fn test_vtkHexagonalPrism_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHexahedron(*mut core::ffi::c_void); impl vtkHexahedron { - /// Creates a new [vtkHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkHexahedron] via `vtkHexahedron::New()` #[doc(alias = "vtkHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHexahedron_get_ptr(self.0) } + Self(unsafe { vtkHexahedron_new() }) } } impl std::default::Default for vtkHexahedron { @@ -3864,37 +40017,21 @@ impl Drop for vtkHexahedron { #[test] fn test_vtkHexahedron_create_drop() { let obj = vtkHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Empty class for backwards compatibility. /// -/// -/// @deprecated vtkHierarchicalBoxDataIterator is deprecated in VTK 9.2 and will be removed. -/// Use `vtkUniformGridAMRDataIterator` instead of `vtkHierarchicalBoxDataIterator`. #[allow(non_camel_case_types)] pub struct vtkHierarchicalBoxDataIterator(*mut core::ffi::c_void); impl vtkHierarchicalBoxDataIterator { - /// Creates a new [vtkHierarchicalBoxDataIterator] wrapped inside `vtkNew` + /// Creates a new [vtkHierarchicalBoxDataIterator] via `vtkHierarchicalBoxDataIterator::New()` #[doc(alias = "vtkHierarchicalBoxDataIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkHierarchicalBoxDataIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHierarchicalBoxDataIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHierarchicalBoxDataIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHierarchicalBoxDataIterator_get_ptr(self.0) } + Self(unsafe { vtkHierarchicalBoxDataIterator_new() }) } } impl std::default::Default for vtkHierarchicalBoxDataIterator { @@ -3914,12 +40051,8 @@ impl Drop for vtkHierarchicalBoxDataIterator { #[test] fn test_vtkHierarchicalBoxDataIterator_create_drop() { let obj = vtkHierarchicalBoxDataIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHierarchicalBoxDataIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Backwards compatibility class /// @@ -3932,22 +40065,13 @@ fn test_vtkHierarchicalBoxDataIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHierarchicalBoxDataSet(*mut core::ffi::c_void); impl vtkHierarchicalBoxDataSet { - /// Creates a new [vtkHierarchicalBoxDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkHierarchicalBoxDataSet] via `vtkHierarchicalBoxDataSet::New()` #[doc(alias = "vtkHierarchicalBoxDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkHierarchicalBoxDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHierarchicalBoxDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHierarchicalBoxDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHierarchicalBoxDataSet_get_ptr(self.0) } + Self(unsafe { vtkHierarchicalBoxDataSet_new() }) } } impl std::default::Default for vtkHierarchicalBoxDataSet { @@ -3967,12 +40091,8 @@ impl Drop for vtkHierarchicalBoxDataSet { #[test] fn test_vtkHierarchicalBoxDataSet_create_drop() { let obj = vtkHierarchicalBoxDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHierarchicalBoxDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A dataset containing a grid of vtkHyperTree instances /// @@ -4018,22 +40138,13 @@ fn test_vtkHierarchicalBoxDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGrid(*mut core::ffi::c_void); impl vtkHyperTreeGrid { - /// Creates a new [vtkHyperTreeGrid] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGrid] via `vtkHyperTreeGrid::New()` #[doc(alias = "vtkHyperTreeGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGrid_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGrid_new() }) } } impl std::default::Default for vtkHyperTreeGrid { @@ -4053,12 +40164,8 @@ impl Drop for vtkHyperTreeGrid { #[test] fn test_vtkHyperTreeGrid_create_drop() { let obj = vtkHyperTreeGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -4083,22 +40190,13 @@ fn test_vtkHyperTreeGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedCursor { - /// Creates a new [vtkHyperTreeGridNonOrientedCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedCursor] via `vtkHyperTreeGridNonOrientedCursor::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedCursor { @@ -4120,12 +40218,8 @@ impl Drop for vtkHyperTreeGridNonOrientedCursor { #[test] fn test_vtkHyperTreeGridNonOrientedCursor_create_drop() { let obj = vtkHyperTreeGridNonOrientedCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -4151,22 +40245,13 @@ fn test_vtkHyperTreeGridNonOrientedCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedGeometryCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedGeometryCursor { - /// Creates a new [vtkHyperTreeGridNonOrientedGeometryCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedGeometryCursor] via `vtkHyperTreeGridNonOrientedGeometryCursor::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedGeometryCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedGeometryCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedGeometryCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedGeometryCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedGeometryCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedGeometryCursor { @@ -4188,12 +40273,8 @@ impl Drop for vtkHyperTreeGridNonOrientedGeometryCursor { #[test] fn test_vtkHyperTreeGridNonOrientedGeometryCursor_create_drop() { let obj = vtkHyperTreeGridNonOrientedGeometryCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedGeometryCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -4218,22 +40299,13 @@ fn test_vtkHyperTreeGridNonOrientedGeometryCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedMooreSuperCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedMooreSuperCursor { - /// Creates a new [vtkHyperTreeGridNonOrientedMooreSuperCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedMooreSuperCursor] via `vtkHyperTreeGridNonOrientedMooreSuperCursor::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedMooreSuperCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedMooreSuperCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedMooreSuperCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedMooreSuperCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedMooreSuperCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedMooreSuperCursor { @@ -4255,12 +40327,8 @@ impl Drop for vtkHyperTreeGridNonOrientedMooreSuperCursor { #[test] fn test_vtkHyperTreeGridNonOrientedMooreSuperCursor_create_drop() { let obj = vtkHyperTreeGridNonOrientedMooreSuperCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedMooreSuperCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -4285,22 +40353,13 @@ fn test_vtkHyperTreeGridNonOrientedMooreSuperCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedMooreSuperCursorLight(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedMooreSuperCursorLight { - /// Creates a new [vtkHyperTreeGridNonOrientedMooreSuperCursorLight] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedMooreSuperCursorLight] via `vtkHyperTreeGridNonOrientedMooreSuperCursorLight::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedMooreSuperCursorLight")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedMooreSuperCursorLight_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedMooreSuperCursorLight_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedMooreSuperCursorLight { @@ -4322,12 +40381,8 @@ impl Drop for vtkHyperTreeGridNonOrientedMooreSuperCursorLight { #[test] fn test_vtkHyperTreeGridNonOrientedMooreSuperCursorLight_create_drop() { let obj = vtkHyperTreeGridNonOrientedMooreSuperCursorLight::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedMooreSuperCursorLight(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -4352,22 +40407,13 @@ fn test_vtkHyperTreeGridNonOrientedMooreSuperCursorLight_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedVonNeumannSuperCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { - /// Creates a new [vtkHyperTreeGridNonOrientedVonNeumannSuperCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedVonNeumannSuperCursor] via `vtkHyperTreeGridNonOrientedVonNeumannSuperCursor::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedVonNeumannSuperCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { @@ -4389,12 +40435,8 @@ impl Drop for vtkHyperTreeGridNonOrientedVonNeumannSuperCursor { #[test] fn test_vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_create_drop() { let obj = vtkHyperTreeGridNonOrientedVonNeumannSuperCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedVonNeumannSuperCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -4419,24 +40461,13 @@ fn test_vtkHyperTreeGridNonOrientedVonNeumannSuperCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight(*mut core::ffi::c_void); impl vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { - /// Creates a new [vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight] via `vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight::New()` #[doc(alias = "vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new() -> *mut core::ffi::c_void; } - Self(unsafe { - &mut *vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new() - }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_new() }) } } impl std::default::Default for vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { @@ -4460,12 +40491,8 @@ impl Drop for vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight { #[test] fn test_vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_create_drop() { let obj = vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -4490,22 +40517,13 @@ fn test_vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridOrientedCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridOrientedCursor { - /// Creates a new [vtkHyperTreeGridOrientedCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridOrientedCursor] via `vtkHyperTreeGridOrientedCursor::New()` #[doc(alias = "vtkHyperTreeGridOrientedCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridOrientedCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridOrientedCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridOrientedCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridOrientedCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridOrientedCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridOrientedCursor { @@ -4525,12 +40543,8 @@ impl Drop for vtkHyperTreeGridOrientedCursor { #[test] fn test_vtkHyperTreeGridOrientedCursor_create_drop() { let obj = vtkHyperTreeGridOrientedCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridOrientedCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects for traversal a HyperTreeGrid. /// @@ -4556,22 +40570,13 @@ fn test_vtkHyperTreeGridOrientedCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHyperTreeGridOrientedGeometryCursor(*mut core::ffi::c_void); impl vtkHyperTreeGridOrientedGeometryCursor { - /// Creates a new [vtkHyperTreeGridOrientedGeometryCursor] wrapped inside `vtkNew` + /// Creates a new [vtkHyperTreeGridOrientedGeometryCursor] via `vtkHyperTreeGridOrientedGeometryCursor::New()` #[doc(alias = "vtkHyperTreeGridOrientedGeometryCursor")] pub fn new() -> Self { unsafe extern "C" { fn vtkHyperTreeGridOrientedGeometryCursor_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHyperTreeGridOrientedGeometryCursor_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHyperTreeGridOrientedGeometryCursor_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHyperTreeGridOrientedGeometryCursor_get_ptr(self.0) } + Self(unsafe { vtkHyperTreeGridOrientedGeometryCursor_new() }) } } impl std::default::Default for vtkHyperTreeGridOrientedGeometryCursor { @@ -4593,12 +40598,8 @@ impl Drop for vtkHyperTreeGridOrientedGeometryCursor { #[test] fn test_vtkHyperTreeGridOrientedGeometryCursor_create_drop() { let obj = vtkHyperTreeGridOrientedGeometryCursor::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHyperTreeGridOrientedGeometryCursor(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// topologically and geometrically regular array of data /// @@ -4616,22 +40617,13 @@ fn test_vtkHyperTreeGridOrientedGeometryCursor_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImageData(*mut core::ffi::c_void); impl vtkImageData { - /// Creates a new [vtkImageData] wrapped inside `vtkNew` + /// Creates a new [vtkImageData] via `vtkImageData::New()` #[doc(alias = "vtkImageData")] pub fn new() -> Self { unsafe extern "C" { fn vtkImageData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImageData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImageData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImageData_get_ptr(self.0) } + Self(unsafe { vtkImageData_new() }) } } impl std::default::Default for vtkImageData { @@ -4651,19 +40643,15 @@ impl Drop for vtkImageData { #[test] fn test_vtkImageData_create_drop() { let obj = vtkImageData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImageData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper class to transform output of non-axis-aligned images /// /// /// vtkImageTransform is a helper class to transform the output of /// image filters (i.e., filter that input vtkImageData) by applying the -/// Index to Physical transformation from the input image, which can +/// Index to Physical transformation frmo the input image, which can /// include origin, spacing, direction. The transformation process is /// threaded with vtkSMPTools for performance. /// @@ -4685,22 +40673,13 @@ fn test_vtkImageData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImageTransform(*mut core::ffi::c_void); impl vtkImageTransform { - /// Creates a new [vtkImageTransform] wrapped inside `vtkNew` + /// Creates a new [vtkImageTransform] via `vtkImageTransform::New()` #[doc(alias = "vtkImageTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkImageTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImageTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImageTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImageTransform_get_ptr(self.0) } + Self(unsafe { vtkImageTransform_new() }) } } impl std::default::Default for vtkImageTransform { @@ -4720,12 +40699,8 @@ impl Drop for vtkImageTransform { #[test] fn test_vtkImageTransform_create_drop() { let obj = vtkImageTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImageTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function consisting of boolean combinations of implicit functions /// @@ -4747,22 +40722,13 @@ fn test_vtkImageTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitBoolean(*mut core::ffi::c_void); impl vtkImplicitBoolean { - /// Creates a new [vtkImplicitBoolean] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitBoolean] via `vtkImplicitBoolean::New()` #[doc(alias = "vtkImplicitBoolean")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitBoolean_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitBoolean_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitBoolean_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitBoolean_get_ptr(self.0) } + Self(unsafe { vtkImplicitBoolean_new() }) } } impl std::default::Default for vtkImplicitBoolean { @@ -4782,12 +40748,8 @@ impl Drop for vtkImplicitBoolean { #[test] fn test_vtkImplicitBoolean_create_drop() { let obj = vtkImplicitBoolean::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitBoolean(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// treat a dataset as if it were an implicit function /// @@ -4814,22 +40776,13 @@ fn test_vtkImplicitBoolean_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitDataSet(*mut core::ffi::c_void); impl vtkImplicitDataSet { - /// Creates a new [vtkImplicitDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitDataSet] via `vtkImplicitDataSet::New()` #[doc(alias = "vtkImplicitDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitDataSet_get_ptr(self.0) } + Self(unsafe { vtkImplicitDataSet_new() }) } } impl std::default::Default for vtkImplicitDataSet { @@ -4849,12 +40802,8 @@ impl Drop for vtkImplicitDataSet { #[test] fn test_vtkImplicitDataSet_create_drop() { let obj = vtkImplicitDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of implicit functions /// @@ -4866,22 +40815,13 @@ fn test_vtkImplicitDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitFunctionCollection(*mut core::ffi::c_void); impl vtkImplicitFunctionCollection { - /// Creates a new [vtkImplicitFunctionCollection] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitFunctionCollection] via `vtkImplicitFunctionCollection::New()` #[doc(alias = "vtkImplicitFunctionCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitFunctionCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitFunctionCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitFunctionCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitFunctionCollection_get_ptr(self.0) } + Self(unsafe { vtkImplicitFunctionCollection_new() }) } } impl std::default::Default for vtkImplicitFunctionCollection { @@ -4901,12 +40841,8 @@ impl Drop for vtkImplicitFunctionCollection { #[test] fn test_vtkImplicitFunctionCollection_create_drop() { let obj = vtkImplicitFunctionCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitFunctionCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for an halo /// @@ -4925,22 +40861,13 @@ fn test_vtkImplicitFunctionCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitHalo(*mut core::ffi::c_void); impl vtkImplicitHalo { - /// Creates a new [vtkImplicitHalo] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitHalo] via `vtkImplicitHalo::New()` #[doc(alias = "vtkImplicitHalo")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitHalo_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitHalo_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitHalo_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitHalo_get_ptr(self.0) } + Self(unsafe { vtkImplicitHalo_new() }) } } impl std::default::Default for vtkImplicitHalo { @@ -4960,12 +40887,8 @@ impl Drop for vtkImplicitHalo { #[test] fn test_vtkImplicitHalo_create_drop() { let obj = vtkImplicitHalo::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitHalo(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a selection loop /// @@ -5000,22 +40923,13 @@ fn test_vtkImplicitHalo_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitSelectionLoop(*mut core::ffi::c_void); impl vtkImplicitSelectionLoop { - /// Creates a new [vtkImplicitSelectionLoop] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitSelectionLoop] via `vtkImplicitSelectionLoop::New()` #[doc(alias = "vtkImplicitSelectionLoop")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitSelectionLoop_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitSelectionLoop_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitSelectionLoop_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitSelectionLoop_get_ptr(self.0) } + Self(unsafe { vtkImplicitSelectionLoop_new() }) } } impl std::default::Default for vtkImplicitSelectionLoop { @@ -5035,12 +40949,8 @@ impl Drop for vtkImplicitSelectionLoop { #[test] fn test_vtkImplicitSelectionLoop_create_drop() { let obj = vtkImplicitSelectionLoop::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitSelectionLoop(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit sum of other implicit functions /// @@ -5053,22 +40963,13 @@ fn test_vtkImplicitSelectionLoop_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitSum(*mut core::ffi::c_void); impl vtkImplicitSum { - /// Creates a new [vtkImplicitSum] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitSum] via `vtkImplicitSum::New()` #[doc(alias = "vtkImplicitSum")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitSum_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitSum_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitSum_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitSum_get_ptr(self.0) } + Self(unsafe { vtkImplicitSum_new() }) } } impl std::default::Default for vtkImplicitSum { @@ -5088,12 +40989,8 @@ impl Drop for vtkImplicitSum { #[test] fn test_vtkImplicitSum_create_drop() { let obj = vtkImplicitSum::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitSum(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// treat a volume as if it were an implicit function /// @@ -5120,22 +41017,13 @@ fn test_vtkImplicitSum_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitVolume(*mut core::ffi::c_void); impl vtkImplicitVolume { - /// Creates a new [vtkImplicitVolume] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitVolume] via `vtkImplicitVolume::New()` #[doc(alias = "vtkImplicitVolume")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitVolume_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitVolume_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitVolume_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitVolume_get_ptr(self.0) } + Self(unsafe { vtkImplicitVolume_new() }) } } impl std::default::Default for vtkImplicitVolume { @@ -5155,12 +41043,8 @@ impl Drop for vtkImplicitVolume { #[test] fn test_vtkImplicitVolume_create_drop() { let obj = vtkImplicitVolume::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitVolume(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function maps another implicit function to lie within a specified range /// @@ -5180,22 +41064,13 @@ fn test_vtkImplicitVolume_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImplicitWindowFunction(*mut core::ffi::c_void); impl vtkImplicitWindowFunction { - /// Creates a new [vtkImplicitWindowFunction] wrapped inside `vtkNew` + /// Creates a new [vtkImplicitWindowFunction] via `vtkImplicitWindowFunction::New()` #[doc(alias = "vtkImplicitWindowFunction")] pub fn new() -> Self { unsafe extern "C" { fn vtkImplicitWindowFunction_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImplicitWindowFunction_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImplicitWindowFunction_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImplicitWindowFunction_get_ptr(self.0) } + Self(unsafe { vtkImplicitWindowFunction_new() }) } } impl std::default::Default for vtkImplicitWindowFunction { @@ -5215,12 +41090,8 @@ impl Drop for vtkImplicitWindowFunction { #[test] fn test_vtkImplicitWindowFunction_create_drop() { let obj = vtkImplicitWindowFunction::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImplicitWindowFunction(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates through all incoming edges to a vertex. /// @@ -5237,22 +41108,13 @@ fn test_vtkImplicitWindowFunction_create_drop() { #[allow(non_camel_case_types)] pub struct vtkInEdgeIterator(*mut core::ffi::c_void); impl vtkInEdgeIterator { - /// Creates a new [vtkInEdgeIterator] wrapped inside `vtkNew` + /// Creates a new [vtkInEdgeIterator] via `vtkInEdgeIterator::New()` #[doc(alias = "vtkInEdgeIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkInEdgeIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkInEdgeIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkInEdgeIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkInEdgeIterator_get_ptr(self.0) } + Self(unsafe { vtkInEdgeIterator_new() }) } } impl std::default::Default for vtkInEdgeIterator { @@ -5272,12 +41134,8 @@ impl Drop for vtkInEdgeIterator { #[test] fn test_vtkInEdgeIterator_create_drop() { let obj = vtkInEdgeIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkInEdgeIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Octree node constituting incremental /// @@ -5323,22 +41181,13 @@ fn test_vtkInEdgeIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIncrementalOctreeNode(*mut core::ffi::c_void); impl vtkIncrementalOctreeNode { - /// Creates a new [vtkIncrementalOctreeNode] wrapped inside `vtkNew` + /// Creates a new [vtkIncrementalOctreeNode] via `vtkIncrementalOctreeNode::New()` #[doc(alias = "vtkIncrementalOctreeNode")] pub fn new() -> Self { unsafe extern "C" { fn vtkIncrementalOctreeNode_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIncrementalOctreeNode_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIncrementalOctreeNode_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIncrementalOctreeNode_get_ptr(self.0) } + Self(unsafe { vtkIncrementalOctreeNode_new() }) } } impl std::default::Default for vtkIncrementalOctreeNode { @@ -5358,12 +41207,8 @@ impl Drop for vtkIncrementalOctreeNode { #[test] fn test_vtkIncrementalOctreeNode_create_drop() { let obj = vtkIncrementalOctreeNode::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIncrementalOctreeNode(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Incremental octree in support /// @@ -5398,22 +41243,13 @@ fn test_vtkIncrementalOctreeNode_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIncrementalOctreePointLocator(*mut core::ffi::c_void); impl vtkIncrementalOctreePointLocator { - /// Creates a new [vtkIncrementalOctreePointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkIncrementalOctreePointLocator] via `vtkIncrementalOctreePointLocator::New()` #[doc(alias = "vtkIncrementalOctreePointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkIncrementalOctreePointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIncrementalOctreePointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIncrementalOctreePointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIncrementalOctreePointLocator_get_ptr(self.0) } + Self(unsafe { vtkIncrementalOctreePointLocator_new() }) } } impl std::default::Default for vtkIncrementalOctreePointLocator { @@ -5435,12 +41271,8 @@ impl Drop for vtkIncrementalOctreePointLocator { #[test] fn test_vtkIncrementalOctreePointLocator_create_drop() { let obj = vtkIncrementalOctreePointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIncrementalOctreePointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implementation of the ICP algorithm. /// @@ -5465,22 +41297,13 @@ fn test_vtkIncrementalOctreePointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIterativeClosestPointTransform(*mut core::ffi::c_void); impl vtkIterativeClosestPointTransform { - /// Creates a new [vtkIterativeClosestPointTransform] wrapped inside `vtkNew` + /// Creates a new [vtkIterativeClosestPointTransform] via `vtkIterativeClosestPointTransform::New()` #[doc(alias = "vtkIterativeClosestPointTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkIterativeClosestPointTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIterativeClosestPointTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIterativeClosestPointTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIterativeClosestPointTransform_get_ptr(self.0) } + Self(unsafe { vtkIterativeClosestPointTransform_new() }) } } impl std::default::Default for vtkIterativeClosestPointTransform { @@ -5502,12 +41325,8 @@ impl Drop for vtkIterativeClosestPointTransform { #[test] fn test_vtkIterativeClosestPointTransform_create_drop() { let obj = vtkIterativeClosestPointTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIterativeClosestPointTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// This class represents a single spatial region /// @@ -5522,22 +41341,13 @@ fn test_vtkIterativeClosestPointTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkKdNode(*mut core::ffi::c_void); impl vtkKdNode { - /// Creates a new [vtkKdNode] wrapped inside `vtkNew` + /// Creates a new [vtkKdNode] via `vtkKdNode::New()` #[doc(alias = "vtkKdNode")] pub fn new() -> Self { unsafe extern "C" { fn vtkKdNode_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkKdNode_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkKdNode_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkKdNode_get_ptr(self.0) } + Self(unsafe { vtkKdNode_new() }) } } impl std::default::Default for vtkKdNode { @@ -5557,12 +41367,8 @@ impl Drop for vtkKdNode { #[test] fn test_vtkKdNode_create_drop() { let obj = vtkKdNode::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkKdNode(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a Kd-tree spatial decomposition of a set of points /// @@ -5600,22 +41406,13 @@ fn test_vtkKdNode_create_drop() { #[allow(non_camel_case_types)] pub struct vtkKdTree(*mut core::ffi::c_void); impl vtkKdTree { - /// Creates a new [vtkKdTree] wrapped inside `vtkNew` + /// Creates a new [vtkKdTree] via `vtkKdTree::New()` #[doc(alias = "vtkKdTree")] pub fn new() -> Self { unsafe extern "C" { fn vtkKdTree_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkKdTree_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkKdTree_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkKdTree_get_ptr(self.0) } + Self(unsafe { vtkKdTree_new() }) } } impl std::default::Default for vtkKdTree { @@ -5635,12 +41432,8 @@ impl Drop for vtkKdTree { #[test] fn test_vtkKdTree_create_drop() { let obj = vtkKdTree::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkKdTree(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// class to quickly locate points in 3-space /// @@ -5653,22 +41446,13 @@ fn test_vtkKdTree_create_drop() { #[allow(non_camel_case_types)] pub struct vtkKdTreePointLocator(*mut core::ffi::c_void); impl vtkKdTreePointLocator { - /// Creates a new [vtkKdTreePointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkKdTreePointLocator] via `vtkKdTreePointLocator::New()` #[doc(alias = "vtkKdTreePointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkKdTreePointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkKdTreePointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkKdTreePointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkKdTreePointLocator_get_ptr(self.0) } + Self(unsafe { vtkKdTreePointLocator_new() }) } } impl std::default::Default for vtkKdTreePointLocator { @@ -5688,33 +41472,20 @@ impl Drop for vtkKdTreePointLocator { #[test] fn test_vtkKdTreePointLocator_create_drop() { let obj = vtkKdTreePointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkKdTreePointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkLagrangeCurve(*mut core::ffi::c_void); impl vtkLagrangeCurve { - /// Creates a new [vtkLagrangeCurve] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeCurve] via `vtkLagrangeCurve::New()` #[doc(alias = "vtkLagrangeCurve")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeCurve_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeCurve_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeCurve_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeCurve_get_ptr(self.0) } + Self(unsafe { vtkLagrangeCurve_new() }) } } impl std::default::Default for vtkLagrangeCurve { @@ -5734,12 +41505,8 @@ impl Drop for vtkLagrangeCurve { #[test] fn test_vtkLagrangeCurve_create_drop() { let obj = vtkLagrangeCurve::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeCurve(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Lagrange hex /// @@ -5752,22 +41519,13 @@ fn test_vtkLagrangeCurve_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLagrangeHexahedron(*mut core::ffi::c_void); impl vtkLagrangeHexahedron { - /// Creates a new [vtkLagrangeHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeHexahedron] via `vtkLagrangeHexahedron::New()` #[doc(alias = "vtkLagrangeHexahedron")] - pub fn new() -> Self { - unsafe extern "C" { - fn vtkLagrangeHexahedron_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkLagrangeHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { + pub fn new() -> Self { unsafe extern "C" { - fn vtkLagrangeHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + fn vtkLagrangeHexahedron_new() -> *mut core::ffi::c_void; } - unsafe { vtkLagrangeHexahedron_get_ptr(self.0) } + Self(unsafe { vtkLagrangeHexahedron_new() }) } } impl std::default::Default for vtkLagrangeHexahedron { @@ -5787,33 +41545,20 @@ impl Drop for vtkLagrangeHexahedron { #[test] fn test_vtkLagrangeHexahedron_create_drop() { let obj = vtkLagrangeHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkLagrangeInterpolation(*mut core::ffi::c_void); impl vtkLagrangeInterpolation { - /// Creates a new [vtkLagrangeInterpolation] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeInterpolation] via `vtkLagrangeInterpolation::New()` #[doc(alias = "vtkLagrangeInterpolation")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeInterpolation_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeInterpolation_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeInterpolation_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeInterpolation_get_ptr(self.0) } + Self(unsafe { vtkLagrangeInterpolation_new() }) } } impl std::default::Default for vtkLagrangeInterpolation { @@ -5833,33 +41578,20 @@ impl Drop for vtkLagrangeInterpolation { #[test] fn test_vtkLagrangeInterpolation_create_drop() { let obj = vtkLagrangeInterpolation::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeInterpolation(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkLagrangeQuadrilateral(*mut core::ffi::c_void); impl vtkLagrangeQuadrilateral { - /// Creates a new [vtkLagrangeQuadrilateral] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeQuadrilateral] via `vtkLagrangeQuadrilateral::New()` #[doc(alias = "vtkLagrangeQuadrilateral")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeQuadrilateral_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeQuadrilateral_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeQuadrilateral_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeQuadrilateral_get_ptr(self.0) } + Self(unsafe { vtkLagrangeQuadrilateral_new() }) } } impl std::default::Default for vtkLagrangeQuadrilateral { @@ -5879,12 +41611,8 @@ impl Drop for vtkLagrangeQuadrilateral { #[test] fn test_vtkLagrangeQuadrilateral_create_drop() { let obj = vtkLagrangeQuadrilateral::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeQuadrilateral(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Lagrange tetrahedron /// @@ -5902,22 +41630,13 @@ fn test_vtkLagrangeQuadrilateral_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLagrangeTetra(*mut core::ffi::c_void); impl vtkLagrangeTetra { - /// Creates a new [vtkLagrangeTetra] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeTetra] via `vtkLagrangeTetra::New()` #[doc(alias = "vtkLagrangeTetra")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeTetra_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeTetra_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeTetra_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeTetra_get_ptr(self.0) } + Self(unsafe { vtkLagrangeTetra_new() }) } } impl std::default::Default for vtkLagrangeTetra { @@ -5937,12 +41656,8 @@ impl Drop for vtkLagrangeTetra { #[test] fn test_vtkLagrangeTetra_create_drop() { let obj = vtkLagrangeTetra::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeTetra(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 2D cell that represents an arbitrary order Lagrange triangle /// @@ -5960,22 +41675,13 @@ fn test_vtkLagrangeTetra_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLagrangeTriangle(*mut core::ffi::c_void); impl vtkLagrangeTriangle { - /// Creates a new [vtkLagrangeTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeTriangle] via `vtkLagrangeTriangle::New()` #[doc(alias = "vtkLagrangeTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeTriangle_get_ptr(self.0) } + Self(unsafe { vtkLagrangeTriangle_new() }) } } impl std::default::Default for vtkLagrangeTriangle { @@ -5995,12 +41701,8 @@ impl Drop for vtkLagrangeTriangle { #[test] fn test_vtkLagrangeTriangle_create_drop() { let obj = vtkLagrangeTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A 3D cell that represents an arbitrary order Lagrange wedge /// @@ -6021,22 +41723,13 @@ fn test_vtkLagrangeTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLagrangeWedge(*mut core::ffi::c_void); impl vtkLagrangeWedge { - /// Creates a new [vtkLagrangeWedge] wrapped inside `vtkNew` + /// Creates a new [vtkLagrangeWedge] via `vtkLagrangeWedge::New()` #[doc(alias = "vtkLagrangeWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkLagrangeWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLagrangeWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLagrangeWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLagrangeWedge_get_ptr(self.0) } + Self(unsafe { vtkLagrangeWedge_new() }) } } impl std::default::Default for vtkLagrangeWedge { @@ -6056,12 +41749,8 @@ impl Drop for vtkLagrangeWedge { #[test] fn test_vtkLagrangeWedge_create_drop() { let obj = vtkLagrangeWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLagrangeWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a 1D line /// @@ -6070,20 +41759,13 @@ fn test_vtkLagrangeWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLine(*mut core::ffi::c_void); impl vtkLine { - /// Creates a new [vtkLine] wrapped inside `vtkNew` + /// Creates a new [vtkLine] via `vtkLine::New()` #[doc(alias = "vtkLine")] pub fn new() -> Self { unsafe extern "C" { fn vtkLine_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLine_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLine_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkLine_get_ptr(self.0) } + Self(unsafe { vtkLine_new() }) } } impl std::default::Default for vtkLine { @@ -6103,12 +41785,8 @@ impl Drop for vtkLine { #[test] fn test_vtkLine_create_drop() { let obj = vtkLine::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLine(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// compute interpolation computes /// @@ -6137,22 +41815,13 @@ fn test_vtkLine_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMeanValueCoordinatesInterpolator(*mut core::ffi::c_void); impl vtkMeanValueCoordinatesInterpolator { - /// Creates a new [vtkMeanValueCoordinatesInterpolator] wrapped inside `vtkNew` + /// Creates a new [vtkMeanValueCoordinatesInterpolator] via `vtkMeanValueCoordinatesInterpolator::New()` #[doc(alias = "vtkMeanValueCoordinatesInterpolator")] pub fn new() -> Self { unsafe extern "C" { fn vtkMeanValueCoordinatesInterpolator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMeanValueCoordinatesInterpolator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMeanValueCoordinatesInterpolator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMeanValueCoordinatesInterpolator_get_ptr(self.0) } + Self(unsafe { vtkMeanValueCoordinatesInterpolator_new() }) } } impl std::default::Default for vtkMeanValueCoordinatesInterpolator { @@ -6174,12 +41843,8 @@ impl Drop for vtkMeanValueCoordinatesInterpolator { #[test] fn test_vtkMeanValueCoordinatesInterpolator_create_drop() { let obj = vtkMeanValueCoordinatesInterpolator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMeanValueCoordinatesInterpolator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// merge exactly coincident points /// @@ -6193,22 +41858,13 @@ fn test_vtkMeanValueCoordinatesInterpolator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMergePoints(*mut core::ffi::c_void); impl vtkMergePoints { - /// Creates a new [vtkMergePoints] wrapped inside `vtkNew` + /// Creates a new [vtkMergePoints] via `vtkMergePoints::New()` #[doc(alias = "vtkMergePoints")] pub fn new() -> Self { unsafe extern "C" { fn vtkMergePoints_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMergePoints_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMergePoints_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMergePoints_get_ptr(self.0) } + Self(unsafe { vtkMergePoints_new() }) } } impl std::default::Default for vtkMergePoints { @@ -6228,12 +41884,8 @@ impl Drop for vtkMergePoints { #[test] fn test_vtkMergePoints_create_drop() { let obj = vtkMergePoints::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMergePoints(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// class describing a molecule /// @@ -6289,22 +41941,13 @@ fn test_vtkMergePoints_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMolecule(*mut core::ffi::c_void); impl vtkMolecule { - /// Creates a new [vtkMolecule] wrapped inside `vtkNew` + /// Creates a new [vtkMolecule] via `vtkMolecule::New()` #[doc(alias = "vtkMolecule")] pub fn new() -> Self { unsafe extern "C" { fn vtkMolecule_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMolecule_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMolecule_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMolecule_get_ptr(self.0) } + Self(unsafe { vtkMolecule_new() }) } } impl std::default::Default for vtkMolecule { @@ -6324,12 +41967,8 @@ impl Drop for vtkMolecule { #[test] fn test_vtkMolecule_create_drop() { let obj = vtkMolecule::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMolecule(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Composite dataset that organizes datasets into /// @@ -6355,22 +41994,13 @@ fn test_vtkMolecule_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiBlockDataSet(*mut core::ffi::c_void); impl vtkMultiBlockDataSet { - /// Creates a new [vtkMultiBlockDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkMultiBlockDataSet] via `vtkMultiBlockDataSet::New()` #[doc(alias = "vtkMultiBlockDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiBlockDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiBlockDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiBlockDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiBlockDataSet_get_ptr(self.0) } + Self(unsafe { vtkMultiBlockDataSet_new() }) } } impl std::default::Default for vtkMultiBlockDataSet { @@ -6390,12 +42020,8 @@ impl Drop for vtkMultiBlockDataSet { #[test] fn test_vtkMultiBlockDataSet_create_drop() { let obj = vtkMultiBlockDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiBlockDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// composite dataset to encapsulates pieces of /// @@ -6415,22 +42041,13 @@ fn test_vtkMultiBlockDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiPieceDataSet(*mut core::ffi::c_void); impl vtkMultiPieceDataSet { - /// Creates a new [vtkMultiPieceDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkMultiPieceDataSet] via `vtkMultiPieceDataSet::New()` #[doc(alias = "vtkMultiPieceDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiPieceDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiPieceDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiPieceDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiPieceDataSet_get_ptr(self.0) } + Self(unsafe { vtkMultiPieceDataSet_new() }) } } impl std::default::Default for vtkMultiPieceDataSet { @@ -6450,12 +42067,8 @@ impl Drop for vtkMultiPieceDataSet { #[test] fn test_vtkMultiPieceDataSet_create_drop() { let obj = vtkMultiPieceDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiPieceDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// An editable directed graph. /// @@ -6472,22 +42085,13 @@ fn test_vtkMultiPieceDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMutableDirectedGraph(*mut core::ffi::c_void); impl vtkMutableDirectedGraph { - /// Creates a new [vtkMutableDirectedGraph] wrapped inside `vtkNew` + /// Creates a new [vtkMutableDirectedGraph] via `vtkMutableDirectedGraph::New()` #[doc(alias = "vtkMutableDirectedGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkMutableDirectedGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMutableDirectedGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMutableDirectedGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMutableDirectedGraph_get_ptr(self.0) } + Self(unsafe { vtkMutableDirectedGraph_new() }) } } impl std::default::Default for vtkMutableDirectedGraph { @@ -6507,12 +42111,8 @@ impl Drop for vtkMutableDirectedGraph { #[test] fn test_vtkMutableDirectedGraph_create_drop() { let obj = vtkMutableDirectedGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMutableDirectedGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// An editable undirected graph. /// @@ -6528,22 +42128,13 @@ fn test_vtkMutableDirectedGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMutableUndirectedGraph(*mut core::ffi::c_void); impl vtkMutableUndirectedGraph { - /// Creates a new [vtkMutableUndirectedGraph] wrapped inside `vtkNew` + /// Creates a new [vtkMutableUndirectedGraph] via `vtkMutableUndirectedGraph::New()` #[doc(alias = "vtkMutableUndirectedGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkMutableUndirectedGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMutableUndirectedGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMutableUndirectedGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMutableUndirectedGraph_get_ptr(self.0) } + Self(unsafe { vtkMutableUndirectedGraph_new() }) } } impl std::default::Default for vtkMutableUndirectedGraph { @@ -6563,12 +42154,8 @@ impl Drop for vtkMutableUndirectedGraph { #[test] fn test_vtkMutableUndirectedGraph_create_drop() { let obj = vtkMutableUndirectedGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMutableUndirectedGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// direct / check-free point insertion. /// @@ -6589,22 +42176,13 @@ fn test_vtkMutableUndirectedGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkNonMergingPointLocator(*mut core::ffi::c_void); impl vtkNonMergingPointLocator { - /// Creates a new [vtkNonMergingPointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkNonMergingPointLocator] via `vtkNonMergingPointLocator::New()` #[doc(alias = "vtkNonMergingPointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkNonMergingPointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkNonMergingPointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkNonMergingPointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkNonMergingPointLocator_get_ptr(self.0) } + Self(unsafe { vtkNonMergingPointLocator_new() }) } } impl std::default::Default for vtkNonMergingPointLocator { @@ -6624,12 +42202,8 @@ impl Drop for vtkNonMergingPointLocator { #[test] fn test_vtkNonMergingPointLocator_create_drop() { let obj = vtkNonMergingPointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkNonMergingPointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A concrete instance of vtkUniformGridAMR to store uniform grids at different /// @@ -6640,22 +42214,13 @@ fn test_vtkNonMergingPointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkNonOverlappingAMR(*mut core::ffi::c_void); impl vtkNonOverlappingAMR { - /// Creates a new [vtkNonOverlappingAMR] wrapped inside `vtkNew` + /// Creates a new [vtkNonOverlappingAMR] via `vtkNonOverlappingAMR::New()` #[doc(alias = "vtkNonOverlappingAMR")] pub fn new() -> Self { unsafe extern "C" { fn vtkNonOverlappingAMR_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkNonOverlappingAMR_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkNonOverlappingAMR_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkNonOverlappingAMR_get_ptr(self.0) } + Self(unsafe { vtkNonOverlappingAMR_new() }) } } impl std::default::Default for vtkNonOverlappingAMR { @@ -6675,12 +42240,8 @@ impl Drop for vtkNonOverlappingAMR { #[test] fn test_vtkNonOverlappingAMR_create_drop() { let obj = vtkNonOverlappingAMR::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkNonOverlappingAMR(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// an octree spatial decomposition of a set of points /// @@ -6699,22 +42260,13 @@ fn test_vtkNonOverlappingAMR_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOctreePointLocator(*mut core::ffi::c_void); impl vtkOctreePointLocator { - /// Creates a new [vtkOctreePointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkOctreePointLocator] via `vtkOctreePointLocator::New()` #[doc(alias = "vtkOctreePointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkOctreePointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOctreePointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOctreePointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOctreePointLocator_get_ptr(self.0) } + Self(unsafe { vtkOctreePointLocator_new() }) } } impl std::default::Default for vtkOctreePointLocator { @@ -6734,12 +42286,8 @@ impl Drop for vtkOctreePointLocator { #[test] fn test_vtkOctreePointLocator_create_drop() { let obj = vtkOctreePointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOctreePointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Octree node that has 8 children each of equal size /// @@ -6758,22 +42306,13 @@ fn test_vtkOctreePointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOctreePointLocatorNode(*mut core::ffi::c_void); impl vtkOctreePointLocatorNode { - /// Creates a new [vtkOctreePointLocatorNode] wrapped inside `vtkNew` + /// Creates a new [vtkOctreePointLocatorNode] via `vtkOctreePointLocatorNode::New()` #[doc(alias = "vtkOctreePointLocatorNode")] pub fn new() -> Self { unsafe extern "C" { fn vtkOctreePointLocatorNode_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOctreePointLocatorNode_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOctreePointLocatorNode_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOctreePointLocatorNode_get_ptr(self.0) } + Self(unsafe { vtkOctreePointLocatorNode_new() }) } } impl std::default::Default for vtkOctreePointLocatorNode { @@ -6793,12 +42332,8 @@ impl Drop for vtkOctreePointLocatorNode { #[test] fn test_vtkOctreePointLocatorNode_create_drop() { let obj = vtkOctreePointLocatorNode::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOctreePointLocatorNode(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper class to generate triangulations /// @@ -6870,22 +42405,13 @@ fn test_vtkOctreePointLocatorNode_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOrderedTriangulator(*mut core::ffi::c_void); impl vtkOrderedTriangulator { - /// Creates a new [vtkOrderedTriangulator] wrapped inside `vtkNew` + /// Creates a new [vtkOrderedTriangulator] via `vtkOrderedTriangulator::New()` #[doc(alias = "vtkOrderedTriangulator")] pub fn new() -> Self { unsafe extern "C" { fn vtkOrderedTriangulator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOrderedTriangulator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOrderedTriangulator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOrderedTriangulator_get_ptr(self.0) } + Self(unsafe { vtkOrderedTriangulator_new() }) } } impl std::default::Default for vtkOrderedTriangulator { @@ -6905,12 +42431,8 @@ impl Drop for vtkOrderedTriangulator { #[test] fn test_vtkOrderedTriangulator_create_drop() { let obj = vtkOrderedTriangulator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOrderedTriangulator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates through all outgoing edges from a vertex. /// @@ -6927,22 +42449,13 @@ fn test_vtkOrderedTriangulator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOutEdgeIterator(*mut core::ffi::c_void); impl vtkOutEdgeIterator { - /// Creates a new [vtkOutEdgeIterator] wrapped inside `vtkNew` + /// Creates a new [vtkOutEdgeIterator] via `vtkOutEdgeIterator::New()` #[doc(alias = "vtkOutEdgeIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkOutEdgeIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOutEdgeIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOutEdgeIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOutEdgeIterator_get_ptr(self.0) } + Self(unsafe { vtkOutEdgeIterator_new() }) } } impl std::default::Default for vtkOutEdgeIterator { @@ -6962,12 +42475,8 @@ impl Drop for vtkOutEdgeIterator { #[test] fn test_vtkOutEdgeIterator_create_drop() { let obj = vtkOutEdgeIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOutEdgeIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// hierarchical dataset of vtkUniformGrids /// @@ -6982,22 +42491,13 @@ fn test_vtkOutEdgeIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOverlappingAMR(*mut core::ffi::c_void); impl vtkOverlappingAMR { - /// Creates a new [vtkOverlappingAMR] wrapped inside `vtkNew` + /// Creates a new [vtkOverlappingAMR] via `vtkOverlappingAMR::New()` #[doc(alias = "vtkOverlappingAMR")] pub fn new() -> Self { unsafe extern "C" { fn vtkOverlappingAMR_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOverlappingAMR_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOverlappingAMR_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOverlappingAMR_get_ptr(self.0) } + Self(unsafe { vtkOverlappingAMR_new() }) } } impl std::default::Default for vtkOverlappingAMR { @@ -7017,12 +42517,8 @@ impl Drop for vtkOverlappingAMR { #[test] fn test_vtkOverlappingAMR_create_drop() { let obj = vtkOverlappingAMR::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOverlappingAMR(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// composite dataset to encapsulates a dataset consisting of /// @@ -7048,22 +42544,13 @@ fn test_vtkOverlappingAMR_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPartitionedDataSet(*mut core::ffi::c_void); impl vtkPartitionedDataSet { - /// Creates a new [vtkPartitionedDataSet] wrapped inside `vtkNew` + /// Creates a new [vtkPartitionedDataSet] via `vtkPartitionedDataSet::New()` #[doc(alias = "vtkPartitionedDataSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkPartitionedDataSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPartitionedDataSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPartitionedDataSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPartitionedDataSet_get_ptr(self.0) } + Self(unsafe { vtkPartitionedDataSet_new() }) } } impl std::default::Default for vtkPartitionedDataSet { @@ -7083,12 +42570,8 @@ impl Drop for vtkPartitionedDataSet { #[test] fn test_vtkPartitionedDataSet_create_drop() { let obj = vtkPartitionedDataSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPartitionedDataSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Composite dataset that groups datasets as a collection. /// @@ -7102,22 +42585,13 @@ fn test_vtkPartitionedDataSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPartitionedDataSetCollection(*mut core::ffi::c_void); impl vtkPartitionedDataSetCollection { - /// Creates a new [vtkPartitionedDataSetCollection] wrapped inside `vtkNew` + /// Creates a new [vtkPartitionedDataSetCollection] via `vtkPartitionedDataSetCollection::New()` #[doc(alias = "vtkPartitionedDataSetCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkPartitionedDataSetCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPartitionedDataSetCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPartitionedDataSetCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPartitionedDataSetCollection_get_ptr(self.0) } + Self(unsafe { vtkPartitionedDataSetCollection_new() }) } } impl std::default::Default for vtkPartitionedDataSetCollection { @@ -7137,12 +42611,8 @@ impl Drop for vtkPartitionedDataSetCollection { #[test] fn test_vtkPartitionedDataSetCollection_create_drop() { let obj = vtkPartitionedDataSetCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPartitionedDataSetCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// concrete dataset representing a path defined by Bezier /// @@ -7153,20 +42623,13 @@ fn test_vtkPartitionedDataSetCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPath(*mut core::ffi::c_void); impl vtkPath { - /// Creates a new [vtkPath] wrapped inside `vtkNew` + /// Creates a new [vtkPath] via `vtkPath::New()` #[doc(alias = "vtkPath")] pub fn new() -> Self { unsafe extern "C" { fn vtkPath_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPath_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPath_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkPath_get_ptr(self.0) } + Self(unsafe { vtkPath_new() }) } } impl std::default::Default for vtkPath { @@ -7186,12 +42649,8 @@ impl Drop for vtkPath { #[test] fn test_vtkPath_create_drop() { let obj = vtkPath::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPath(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a convex prism with /// @@ -7220,22 +42679,13 @@ fn test_vtkPath_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPentagonalPrism(*mut core::ffi::c_void); impl vtkPentagonalPrism { - /// Creates a new [vtkPentagonalPrism] wrapped inside `vtkNew` + /// Creates a new [vtkPentagonalPrism] via `vtkPentagonalPrism::New()` #[doc(alias = "vtkPentagonalPrism")] pub fn new() -> Self { unsafe extern "C" { fn vtkPentagonalPrism_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPentagonalPrism_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPentagonalPrism_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPentagonalPrism_get_ptr(self.0) } + Self(unsafe { vtkPentagonalPrism_new() }) } } impl std::default::Default for vtkPentagonalPrism { @@ -7255,12 +42705,8 @@ impl Drop for vtkPentagonalPrism { #[test] fn test_vtkPentagonalPrism_create_drop() { let obj = vtkPentagonalPrism::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPentagonalPrism(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// an implicit function that implements Perlin noise /// @@ -7279,22 +42725,13 @@ fn test_vtkPentagonalPrism_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPerlinNoise(*mut core::ffi::c_void); impl vtkPerlinNoise { - /// Creates a new [vtkPerlinNoise] wrapped inside `vtkNew` + /// Creates a new [vtkPerlinNoise] via `vtkPerlinNoise::New()` #[doc(alias = "vtkPerlinNoise")] pub fn new() -> Self { unsafe extern "C" { fn vtkPerlinNoise_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPerlinNoise_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPerlinNoise_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPerlinNoise_get_ptr(self.0) } + Self(unsafe { vtkPerlinNoise_new() }) } } impl std::default::Default for vtkPerlinNoise { @@ -7314,12 +42751,8 @@ impl Drop for vtkPerlinNoise { #[test] fn test_vtkPerlinNoise_create_drop() { let obj = vtkPerlinNoise::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPerlinNoise(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Defines a 1D piecewise function. /// @@ -7342,22 +42775,13 @@ fn test_vtkPerlinNoise_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPiecewiseFunction(*mut core::ffi::c_void); impl vtkPiecewiseFunction { - /// Creates a new [vtkPiecewiseFunction] wrapped inside `vtkNew` + /// Creates a new [vtkPiecewiseFunction] via `vtkPiecewiseFunction::New()` #[doc(alias = "vtkPiecewiseFunction")] pub fn new() -> Self { unsafe extern "C" { fn vtkPiecewiseFunction_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPiecewiseFunction_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPiecewiseFunction_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPiecewiseFunction_get_ptr(self.0) } + Self(unsafe { vtkPiecewiseFunction_new() }) } } impl std::default::Default for vtkPiecewiseFunction { @@ -7377,12 +42801,8 @@ impl Drop for vtkPiecewiseFunction { #[test] fn test_vtkPiecewiseFunction_create_drop() { let obj = vtkPiecewiseFunction::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPiecewiseFunction(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents an orthogonal quadrilateral /// @@ -7394,20 +42814,13 @@ fn test_vtkPiecewiseFunction_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPixel(*mut core::ffi::c_void); impl vtkPixel { - /// Creates a new [vtkPixel] wrapped inside `vtkNew` + /// Creates a new [vtkPixel] via `vtkPixel::New()` #[doc(alias = "vtkPixel")] pub fn new() -> Self { unsafe extern "C" { fn vtkPixel_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPixel_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPixel_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkPixel_get_ptr(self.0) } + Self(unsafe { vtkPixel_new() }) } } impl std::default::Default for vtkPixel { @@ -7427,12 +42840,8 @@ impl Drop for vtkPixel { #[test] fn test_vtkPixel_create_drop() { let obj = vtkPixel::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPixel(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// perform various plane computations /// @@ -7444,20 +42853,13 @@ fn test_vtkPixel_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPlane(*mut core::ffi::c_void); impl vtkPlane { - /// Creates a new [vtkPlane] wrapped inside `vtkNew` + /// Creates a new [vtkPlane] via `vtkPlane::New()` #[doc(alias = "vtkPlane")] pub fn new() -> Self { unsafe extern "C" { fn vtkPlane_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPlane_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPlane_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkPlane_get_ptr(self.0) } + Self(unsafe { vtkPlane_new() }) } } impl std::default::Default for vtkPlane { @@ -7477,12 +42879,8 @@ impl Drop for vtkPlane { #[test] fn test_vtkPlane_create_drop() { let obj = vtkPlane::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPlane(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of planes /// @@ -7494,22 +42892,13 @@ fn test_vtkPlane_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPlaneCollection(*mut core::ffi::c_void); impl vtkPlaneCollection { - /// Creates a new [vtkPlaneCollection] wrapped inside `vtkNew` + /// Creates a new [vtkPlaneCollection] via `vtkPlaneCollection::New()` #[doc(alias = "vtkPlaneCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkPlaneCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPlaneCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPlaneCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPlaneCollection_get_ptr(self.0) } + Self(unsafe { vtkPlaneCollection_new() }) } } impl std::default::Default for vtkPlaneCollection { @@ -7529,12 +42918,8 @@ impl Drop for vtkPlaneCollection { #[test] fn test_vtkPlaneCollection_create_drop() { let obj = vtkPlaneCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPlaneCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for convex set of planes /// @@ -7560,22 +42945,13 @@ fn test_vtkPlaneCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPlanes(*mut core::ffi::c_void); impl vtkPlanes { - /// Creates a new [vtkPlanes] wrapped inside `vtkNew` + /// Creates a new [vtkPlanes] via `vtkPlanes::New()` #[doc(alias = "vtkPlanes")] pub fn new() -> Self { unsafe extern "C" { fn vtkPlanes_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPlanes_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPlanes_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPlanes_get_ptr(self.0) } + Self(unsafe { vtkPlanes_new() }) } } impl std::default::Default for vtkPlanes { @@ -7595,12 +42971,8 @@ impl Drop for vtkPlanes { #[test] fn test_vtkPlanes_create_drop() { let obj = vtkPlanes::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPlanes(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A vtkPlanesIntersection object is a /// @@ -7623,22 +42995,13 @@ fn test_vtkPlanes_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPlanesIntersection(*mut core::ffi::c_void); impl vtkPlanesIntersection { - /// Creates a new [vtkPlanesIntersection] wrapped inside `vtkNew` + /// Creates a new [vtkPlanesIntersection] via `vtkPlanesIntersection::New()` #[doc(alias = "vtkPlanesIntersection")] pub fn new() -> Self { unsafe extern "C" { fn vtkPlanesIntersection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPlanesIntersection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPlanesIntersection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPlanesIntersection_get_ptr(self.0) } + Self(unsafe { vtkPlanesIntersection_new() }) } } impl std::default::Default for vtkPlanesIntersection { @@ -7658,12 +43021,8 @@ impl Drop for vtkPlanesIntersection { #[test] fn test_vtkPlanesIntersection_create_drop() { let obj = vtkPlanesIntersection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPlanesIntersection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate point attribute data /// @@ -7671,29 +43030,17 @@ fn test_vtkPlanesIntersection_create_drop() { /// vtkPointData is a class that is used to represent and manipulate /// point attribute data (e.g., scalars, vectors, normals, texture /// coordinates, etc.) Most of the functionality is handled by -/// vtkDataSetAttributes. -/// -/// By default, `GhostTypesToSkip` is set to `DUPLICATEPOINT | HIDDENPOINT`. -/// See `vtkDataSetAttributes` for the definition of those constants. +/// vtkDataSetAttributes #[allow(non_camel_case_types)] pub struct vtkPointData(*mut core::ffi::c_void); impl vtkPointData { - /// Creates a new [vtkPointData] wrapped inside `vtkNew` + /// Creates a new [vtkPointData] via `vtkPointData::New()` #[doc(alias = "vtkPointData")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointData_get_ptr(self.0) } + Self(unsafe { vtkPointData_new() }) } } impl std::default::Default for vtkPointData { @@ -7713,12 +43060,8 @@ impl Drop for vtkPointData { #[test] fn test_vtkPointData_create_drop() { let obj = vtkPointData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// quickly locate points in 3-space /// @@ -7739,34 +43082,18 @@ fn test_vtkPointData_create_drop() { /// octrees and kd-trees. These are often more efficient for the /// operations described here. /// -/// @warning -/// Frequently vtkStaticPointLocator is used in lieu of vtkPointLocator. -/// They are very similar in terms of algorithmic approach, however -/// vtkStaticCellLocator is threaded and is typically much faster for -/// a large number of points (on the order of 3-5x faster). For small numbers -/// of points, vtkPointLocator is just as fast as vtkStaticPointLocator. -/// /// @sa /// vtkCellPicker vtkPointPicker vtkStaticPointLocator #[allow(non_camel_case_types)] pub struct vtkPointLocator(*mut core::ffi::c_void); impl vtkPointLocator { - /// Creates a new [vtkPointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkPointLocator] via `vtkPointLocator::New()` #[doc(alias = "vtkPointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointLocator_get_ptr(self.0) } + Self(unsafe { vtkPointLocator_new() }) } } impl std::default::Default for vtkPointLocator { @@ -7786,12 +43113,8 @@ impl Drop for vtkPointLocator { #[test] fn test_vtkPointLocator_create_drop() { let obj = vtkPointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// concrete class for storing a set of points /// @@ -7830,22 +43153,13 @@ fn test_vtkPointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointSet(*mut core::ffi::c_void); impl vtkPointSet { - /// Creates a new [vtkPointSet] wrapped inside `vtkNew` + /// Creates a new [vtkPointSet] via `vtkPointSet::New()` #[doc(alias = "vtkPointSet")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointSet_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointSet_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointSet_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointSet_get_ptr(self.0) } + Self(unsafe { vtkPointSet_new() }) } } impl std::default::Default for vtkPointSet { @@ -7865,12 +43179,8 @@ impl Drop for vtkPointSet { #[test] fn test_vtkPointSet_create_drop() { let obj = vtkPointSet::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointSet(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implementation of vtkCellIterator using /// @@ -7878,22 +43188,13 @@ fn test_vtkPointSet_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointSetCellIterator(*mut core::ffi::c_void); impl vtkPointSetCellIterator { - /// Creates a new [vtkPointSetCellIterator] wrapped inside `vtkNew` + /// Creates a new [vtkPointSetCellIterator] via `vtkPointSetCellIterator::New()` #[doc(alias = "vtkPointSetCellIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointSetCellIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointSetCellIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointSetCellIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointSetCellIterator_get_ptr(self.0) } + Self(unsafe { vtkPointSetCellIterator_new() }) } } impl std::default::Default for vtkPointSetCellIterator { @@ -7913,12 +43214,8 @@ impl Drop for vtkPointSetCellIterator { #[test] fn test_vtkPointSetCellIterator_create_drop() { let obj = vtkPointSetCellIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointSetCellIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// the convex hull of the orthogonal /// @@ -7932,22 +43229,13 @@ fn test_vtkPointSetCellIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointsProjectedHull(*mut core::ffi::c_void); impl vtkPointsProjectedHull { - /// Creates a new [vtkPointsProjectedHull] wrapped inside `vtkNew` + /// Creates a new [vtkPointsProjectedHull] via `vtkPointsProjectedHull::New()` #[doc(alias = "vtkPointsProjectedHull")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointsProjectedHull_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointsProjectedHull_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointsProjectedHull_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointsProjectedHull_get_ptr(self.0) } + Self(unsafe { vtkPointsProjectedHull_new() }) } } impl std::default::Default for vtkPointsProjectedHull { @@ -7967,12 +43255,8 @@ impl Drop for vtkPointsProjectedHull { #[test] fn test_vtkPointsProjectedHull_create_drop() { let obj = vtkPointsProjectedHull::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointsProjectedHull(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// concrete dataset represents vertices, lines, polygons, and triangle strips /// @@ -8021,22 +43305,13 @@ fn test_vtkPointsProjectedHull_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyData(*mut core::ffi::c_void); impl vtkPolyData { - /// Creates a new [vtkPolyData] wrapped inside `vtkNew` + /// Creates a new [vtkPolyData] via `vtkPolyData::New()` #[doc(alias = "vtkPolyData")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyData_get_ptr(self.0) } + Self(unsafe { vtkPolyData_new() }) } } impl std::default::Default for vtkPolyData { @@ -8056,12 +43331,8 @@ impl Drop for vtkPolyData { #[test] fn test_vtkPolyData_create_drop() { let obj = vtkPolyData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of polygonal data objects /// @@ -8074,22 +43345,13 @@ fn test_vtkPolyData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyDataCollection(*mut core::ffi::c_void); impl vtkPolyDataCollection { - /// Creates a new [vtkPolyDataCollection] wrapped inside `vtkNew` + /// Creates a new [vtkPolyDataCollection] via `vtkPolyDataCollection::New()` #[doc(alias = "vtkPolyDataCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyDataCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyDataCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyDataCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyDataCollection_get_ptr(self.0) } + Self(unsafe { vtkPolyDataCollection_new() }) } } impl std::default::Default for vtkPolyDataCollection { @@ -8109,12 +43371,8 @@ impl Drop for vtkPolyDataCollection { #[test] fn test_vtkPolyDataCollection_create_drop() { let obj = vtkPolyDataCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyDataCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a set of 1D lines /// @@ -8124,22 +43382,13 @@ fn test_vtkPolyDataCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyLine(*mut core::ffi::c_void); impl vtkPolyLine { - /// Creates a new [vtkPolyLine] wrapped inside `vtkNew` + /// Creates a new [vtkPolyLine] via `vtkPolyLine::New()` #[doc(alias = "vtkPolyLine")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyLine_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyLine_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyLine_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyLine_get_ptr(self.0) } + Self(unsafe { vtkPolyLine_new() }) } } impl std::default::Default for vtkPolyLine { @@ -8159,12 +43408,8 @@ impl Drop for vtkPolyLine { #[test] fn test_vtkPolyLine_create_drop() { let obj = vtkPolyLine::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyLine(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implicit function that is generated by extrusion of a polyline along the Z axis /// @@ -8180,22 +43425,13 @@ fn test_vtkPolyLine_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyPlane(*mut core::ffi::c_void); impl vtkPolyPlane { - /// Creates a new [vtkPolyPlane] wrapped inside `vtkNew` + /// Creates a new [vtkPolyPlane] via `vtkPolyPlane::New()` #[doc(alias = "vtkPolyPlane")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyPlane_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyPlane_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyPlane_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyPlane_get_ptr(self.0) } + Self(unsafe { vtkPolyPlane_new() }) } } impl std::default::Default for vtkPolyPlane { @@ -8215,12 +43451,8 @@ impl Drop for vtkPolyPlane { #[test] fn test_vtkPolyPlane_create_drop() { let obj = vtkPolyPlane::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyPlane(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a set of 0D vertices /// @@ -8230,22 +43462,13 @@ fn test_vtkPolyPlane_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyVertex(*mut core::ffi::c_void); impl vtkPolyVertex { - /// Creates a new [vtkPolyVertex] wrapped inside `vtkNew` + /// Creates a new [vtkPolyVertex] via `vtkPolyVertex::New()` #[doc(alias = "vtkPolyVertex")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyVertex_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyVertex_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyVertex_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyVertex_get_ptr(self.0) } + Self(unsafe { vtkPolyVertex_new() }) } } impl std::default::Default for vtkPolyVertex { @@ -8265,12 +43488,8 @@ impl Drop for vtkPolyVertex { #[test] fn test_vtkPolyVertex_create_drop() { let obj = vtkPolyVertex::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyVertex(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents an n-sided polygon /// @@ -8282,22 +43501,13 @@ fn test_vtkPolyVertex_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolygon(*mut core::ffi::c_void); impl vtkPolygon { - /// Creates a new [vtkPolygon] wrapped inside `vtkNew` + /// Creates a new [vtkPolygon] via `vtkPolygon::New()` #[doc(alias = "vtkPolygon")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolygon_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolygon_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolygon_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolygon_get_ptr(self.0) } + Self(unsafe { vtkPolygon_new() }) } } impl std::default::Default for vtkPolygon { @@ -8317,12 +43527,8 @@ impl Drop for vtkPolygon { #[test] fn test_vtkPolygon_create_drop() { let obj = vtkPolygon::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolygon(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell defined by a set of polygonal faces /// @@ -8340,26 +43546,17 @@ fn test_vtkPolygon_create_drop() { /// definitely cause problems, especially in severely warped situations. /// /// @sa -/// vtkCell3D vtkConvexPointSet vtkMeanValueCoordinatesInterpolator +/// vtkCell3D vtkConvecPointSet vtkMeanValueCoordinatesInterpolator #[allow(non_camel_case_types)] pub struct vtkPolyhedron(*mut core::ffi::c_void); impl vtkPolyhedron { - /// Creates a new [vtkPolyhedron] wrapped inside `vtkNew` + /// Creates a new [vtkPolyhedron] via `vtkPolyhedron::New()` #[doc(alias = "vtkPolyhedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyhedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyhedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyhedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyhedron_get_ptr(self.0) } + Self(unsafe { vtkPolyhedron_new() }) } } impl std::default::Default for vtkPolyhedron { @@ -8379,12 +43576,8 @@ impl Drop for vtkPolyhedron { #[test] fn test_vtkPolyhedron_create_drop() { let obj = vtkPolyhedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyhedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a linear pyramid /// @@ -8402,22 +43595,13 @@ fn test_vtkPolyhedron_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPyramid(*mut core::ffi::c_void); impl vtkPyramid { - /// Creates a new [vtkPyramid] wrapped inside `vtkNew` + /// Creates a new [vtkPyramid] via `vtkPyramid::New()` #[doc(alias = "vtkPyramid")] pub fn new() -> Self { unsafe extern "C" { fn vtkPyramid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPyramid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPyramid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPyramid_get_ptr(self.0) } + Self(unsafe { vtkPyramid_new() }) } } impl std::default::Default for vtkPyramid { @@ -8437,12 +43621,8 @@ impl Drop for vtkPyramid { #[test] fn test_vtkPyramid_create_drop() { let obj = vtkPyramid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPyramid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a 2D quadrilateral /// @@ -8454,20 +43634,13 @@ fn test_vtkPyramid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuad(*mut core::ffi::c_void); impl vtkQuad { - /// Creates a new [vtkQuad] wrapped inside `vtkNew` + /// Creates a new [vtkQuad] via `vtkQuad::New()` #[doc(alias = "vtkQuad")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuad_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuad_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuad_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkQuad_get_ptr(self.0) } + Self(unsafe { vtkQuad_new() }) } } impl std::default::Default for vtkQuad { @@ -8487,12 +43660,8 @@ impl Drop for vtkQuad { #[test] fn test_vtkQuad_create_drop() { let obj = vtkQuad::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuad(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, isoparametric edge /// @@ -8510,22 +43679,13 @@ fn test_vtkQuad_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticEdge(*mut core::ffi::c_void); impl vtkQuadraticEdge { - /// Creates a new [vtkQuadraticEdge] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticEdge] via `vtkQuadraticEdge::New()` #[doc(alias = "vtkQuadraticEdge")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticEdge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticEdge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticEdge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticEdge_get_ptr(self.0) } + Self(unsafe { vtkQuadraticEdge_new() }) } } impl std::default::Default for vtkQuadraticEdge { @@ -8545,12 +43705,8 @@ impl Drop for vtkQuadraticEdge { #[test] fn test_vtkQuadraticEdge_create_drop() { let obj = vtkQuadraticEdge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticEdge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 20-node isoparametric hexahedron /// @@ -8571,22 +43727,13 @@ fn test_vtkQuadraticEdge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticHexahedron(*mut core::ffi::c_void); impl vtkQuadraticHexahedron { - /// Creates a new [vtkQuadraticHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticHexahedron] via `vtkQuadraticHexahedron::New()` #[doc(alias = "vtkQuadraticHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticHexahedron_get_ptr(self.0) } + Self(unsafe { vtkQuadraticHexahedron_new() }) } } impl std::default::Default for vtkQuadraticHexahedron { @@ -8606,12 +43753,8 @@ impl Drop for vtkQuadraticHexahedron { #[test] fn test_vtkQuadraticHexahedron_create_drop() { let obj = vtkQuadraticHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a quadratic-linear, 6-node isoparametric quad /// @@ -8634,22 +43777,13 @@ fn test_vtkQuadraticHexahedron_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticLinearQuad(*mut core::ffi::c_void); impl vtkQuadraticLinearQuad { - /// Creates a new [vtkQuadraticLinearQuad] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticLinearQuad] via `vtkQuadraticLinearQuad::New()` #[doc(alias = "vtkQuadraticLinearQuad")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticLinearQuad_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticLinearQuad_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticLinearQuad_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticLinearQuad_get_ptr(self.0) } + Self(unsafe { vtkQuadraticLinearQuad_new() }) } } impl std::default::Default for vtkQuadraticLinearQuad { @@ -8669,12 +43803,8 @@ impl Drop for vtkQuadraticLinearQuad { #[test] fn test_vtkQuadraticLinearQuad_create_drop() { let obj = vtkQuadraticLinearQuad::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticLinearQuad(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a, 12-node isoparametric wedge /// @@ -8700,22 +43830,13 @@ fn test_vtkQuadraticLinearQuad_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticLinearWedge(*mut core::ffi::c_void); impl vtkQuadraticLinearWedge { - /// Creates a new [vtkQuadraticLinearWedge] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticLinearWedge] via `vtkQuadraticLinearWedge::New()` #[doc(alias = "vtkQuadraticLinearWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticLinearWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticLinearWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticLinearWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticLinearWedge_get_ptr(self.0) } + Self(unsafe { vtkQuadraticLinearWedge_new() }) } } impl std::default::Default for vtkQuadraticLinearWedge { @@ -8735,12 +43856,8 @@ impl Drop for vtkQuadraticLinearWedge { #[test] fn test_vtkQuadraticLinearWedge_create_drop() { let obj = vtkQuadraticLinearWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticLinearWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a parabolic n-sided polygon /// @@ -8760,22 +43877,13 @@ fn test_vtkQuadraticLinearWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticPolygon(*mut core::ffi::c_void); impl vtkQuadraticPolygon { - /// Creates a new [vtkQuadraticPolygon] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticPolygon] via `vtkQuadraticPolygon::New()` #[doc(alias = "vtkQuadraticPolygon")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticPolygon_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticPolygon_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticPolygon_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticPolygon_get_ptr(self.0) } + Self(unsafe { vtkQuadraticPolygon_new() }) } } impl std::default::Default for vtkQuadraticPolygon { @@ -8795,12 +43903,8 @@ impl Drop for vtkQuadraticPolygon { #[test] fn test_vtkQuadraticPolygon_create_drop() { let obj = vtkQuadraticPolygon::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticPolygon(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 13-node isoparametric pyramid /// @@ -8826,22 +43930,13 @@ fn test_vtkQuadraticPolygon_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticPyramid(*mut core::ffi::c_void); impl vtkQuadraticPyramid { - /// Creates a new [vtkQuadraticPyramid] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticPyramid] via `vtkQuadraticPyramid::New()` #[doc(alias = "vtkQuadraticPyramid")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticPyramid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticPyramid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticPyramid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticPyramid_get_ptr(self.0) } + Self(unsafe { vtkQuadraticPyramid_new() }) } } impl std::default::Default for vtkQuadraticPyramid { @@ -8861,12 +43956,8 @@ impl Drop for vtkQuadraticPyramid { #[test] fn test_vtkQuadraticPyramid_create_drop() { let obj = vtkQuadraticPyramid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticPyramid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 8-node isoparametric quad /// @@ -8886,22 +43977,13 @@ fn test_vtkQuadraticPyramid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticQuad(*mut core::ffi::c_void); impl vtkQuadraticQuad { - /// Creates a new [vtkQuadraticQuad] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticQuad] via `vtkQuadraticQuad::New()` #[doc(alias = "vtkQuadraticQuad")] pub fn new() -> Self { unsafe extern "C" { - fn vtkQuadraticQuad_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkQuadraticQuad_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticQuad_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; + fn vtkQuadraticQuad_new() -> *mut core::ffi::c_void; } - unsafe { vtkQuadraticQuad_get_ptr(self.0) } + Self(unsafe { vtkQuadraticQuad_new() }) } } impl std::default::Default for vtkQuadraticQuad { @@ -8921,12 +44003,8 @@ impl Drop for vtkQuadraticQuad { #[test] fn test_vtkQuadraticQuad_create_drop() { let obj = vtkQuadraticQuad::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticQuad(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 10-node isoparametric tetrahedron /// @@ -8950,22 +44028,13 @@ fn test_vtkQuadraticQuad_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticTetra(*mut core::ffi::c_void); impl vtkQuadraticTetra { - /// Creates a new [vtkQuadraticTetra] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticTetra] via `vtkQuadraticTetra::New()` #[doc(alias = "vtkQuadraticTetra")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticTetra_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticTetra_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticTetra_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticTetra_get_ptr(self.0) } + Self(unsafe { vtkQuadraticTetra_new() }) } } impl std::default::Default for vtkQuadraticTetra { @@ -8985,12 +44054,8 @@ impl Drop for vtkQuadraticTetra { #[test] fn test_vtkQuadraticTetra_create_drop() { let obj = vtkQuadraticTetra::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticTetra(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, isoparametric triangle /// @@ -9010,22 +44075,13 @@ fn test_vtkQuadraticTetra_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticTriangle(*mut core::ffi::c_void); impl vtkQuadraticTriangle { - /// Creates a new [vtkQuadraticTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticTriangle] via `vtkQuadraticTriangle::New()` #[doc(alias = "vtkQuadraticTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticTriangle_get_ptr(self.0) } + Self(unsafe { vtkQuadraticTriangle_new() }) } } impl std::default::Default for vtkQuadraticTriangle { @@ -9045,12 +44101,8 @@ impl Drop for vtkQuadraticTriangle { #[test] fn test_vtkQuadraticTriangle_create_drop() { let obj = vtkQuadraticTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 15-node isoparametric wedge /// @@ -9073,22 +44125,13 @@ fn test_vtkQuadraticTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadraticWedge(*mut core::ffi::c_void); impl vtkQuadraticWedge { - /// Creates a new [vtkQuadraticWedge] wrapped inside `vtkNew` + /// Creates a new [vtkQuadraticWedge] via `vtkQuadraticWedge::New()` #[doc(alias = "vtkQuadraticWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadraticWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadraticWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadraticWedge_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadraticWedge_get_ptr(self.0) } + Self(unsafe { vtkQuadraticWedge_new() }) } } impl std::default::Default for vtkQuadraticWedge { @@ -9108,12 +44151,8 @@ impl Drop for vtkQuadraticWedge { #[test] fn test_vtkQuadraticWedge_create_drop() { let obj = vtkQuadraticWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadraticWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// An Elemental data type that holds a definition of a @@ -9128,28 +44167,19 @@ fn test_vtkQuadraticWedge_create_drop() { /// /// 2) /// The number of quadrature points and cell nodes. These parameters -/// size the matrix, and allow for convenient evaluation by users +/// size the matrix, and allow for convinent evaluation by users /// of the definition. /// #[allow(non_camel_case_types)] pub struct vtkQuadratureSchemeDefinition(*mut core::ffi::c_void); impl vtkQuadratureSchemeDefinition { - /// Creates a new [vtkQuadratureSchemeDefinition] wrapped inside `vtkNew` + /// Creates a new [vtkQuadratureSchemeDefinition] via `vtkQuadratureSchemeDefinition::New()` #[doc(alias = "vtkQuadratureSchemeDefinition")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadratureSchemeDefinition_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadratureSchemeDefinition_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadratureSchemeDefinition_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadratureSchemeDefinition_get_ptr(self.0) } + Self(unsafe { vtkQuadratureSchemeDefinition_new() }) } } impl std::default::Default for vtkQuadratureSchemeDefinition { @@ -9169,12 +44199,8 @@ impl Drop for vtkQuadratureSchemeDefinition { #[test] fn test_vtkQuadratureSchemeDefinition_create_drop() { let obj = vtkQuadratureSchemeDefinition::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadratureSchemeDefinition(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// evaluate implicit quadric function /// @@ -9185,22 +44211,13 @@ fn test_vtkQuadratureSchemeDefinition_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuadric(*mut core::ffi::c_void); impl vtkQuadric { - /// Creates a new [vtkQuadric] wrapped inside `vtkNew` + /// Creates a new [vtkQuadric] via `vtkQuadric::New()` #[doc(alias = "vtkQuadric")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuadric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuadric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuadric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuadric_get_ptr(self.0) } + Self(unsafe { vtkQuadric_new() }) } } impl std::default::Default for vtkQuadric { @@ -9220,12 +44237,8 @@ impl Drop for vtkQuadric { #[test] fn test_vtkQuadric_create_drop() { let obj = vtkQuadric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuadric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a dataset that is topologically regular with variable spacing in the three coordinate /// @@ -9249,22 +44262,13 @@ fn test_vtkQuadric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRectilinearGrid(*mut core::ffi::c_void); impl vtkRectilinearGrid { - /// Creates a new [vtkRectilinearGrid] wrapped inside `vtkNew` + /// Creates a new [vtkRectilinearGrid] via `vtkRectilinearGrid::New()` #[doc(alias = "vtkRectilinearGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkRectilinearGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRectilinearGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRectilinearGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRectilinearGrid_get_ptr(self.0) } + Self(unsafe { vtkRectilinearGrid_new() }) } } impl std::default::Default for vtkRectilinearGrid { @@ -9284,12 +44288,8 @@ impl Drop for vtkRectilinearGrid { #[test] fn test_vtkRectilinearGrid_create_drop() { let obj = vtkRectilinearGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRectilinearGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Reeb graph computation for PL scalar fields. /// @@ -9389,22 +44389,13 @@ fn test_vtkRectilinearGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkReebGraph(*mut core::ffi::c_void); impl vtkReebGraph { - /// Creates a new [vtkReebGraph] wrapped inside `vtkNew` + /// Creates a new [vtkReebGraph] via `vtkReebGraph::New()` #[doc(alias = "vtkReebGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkReebGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkReebGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkReebGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkReebGraph_get_ptr(self.0) } + Self(unsafe { vtkReebGraph_new() }) } } impl std::default::Default for vtkReebGraph { @@ -9424,12 +44415,8 @@ impl Drop for vtkReebGraph { #[test] fn test_vtkReebGraph_create_drop() { let obj = vtkReebGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkReebGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// abstract class for custom Reeb graph /// @@ -9462,22 +44449,13 @@ fn test_vtkReebGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkReebGraphSimplificationMetric(*mut core::ffi::c_void); impl vtkReebGraphSimplificationMetric { - /// Creates a new [vtkReebGraphSimplificationMetric] wrapped inside `vtkNew` + /// Creates a new [vtkReebGraphSimplificationMetric] via `vtkReebGraphSimplificationMetric::New()` #[doc(alias = "vtkReebGraphSimplificationMetric")] pub fn new() -> Self { unsafe extern "C" { fn vtkReebGraphSimplificationMetric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkReebGraphSimplificationMetric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkReebGraphSimplificationMetric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkReebGraphSimplificationMetric_get_ptr(self.0) } + Self(unsafe { vtkReebGraphSimplificationMetric_new() }) } } impl std::default::Default for vtkReebGraphSimplificationMetric { @@ -9499,12 +44477,8 @@ impl Drop for vtkReebGraphSimplificationMetric { #[test] fn test_vtkReebGraphSimplificationMetric_create_drop() { let obj = vtkReebGraphSimplificationMetric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkReebGraphSimplificationMetric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// data object that represents a "selection" in VTK. /// @@ -9531,22 +44505,13 @@ fn test_vtkReebGraphSimplificationMetric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSelection(*mut core::ffi::c_void); impl vtkSelection { - /// Creates a new [vtkSelection] wrapped inside `vtkNew` + /// Creates a new [vtkSelection] via `vtkSelection::New()` #[doc(alias = "vtkSelection")] pub fn new() -> Self { unsafe extern "C" { fn vtkSelection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSelection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSelection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSelection_get_ptr(self.0) } + Self(unsafe { vtkSelection_new() }) } } impl std::default::Default for vtkSelection { @@ -9566,12 +44531,8 @@ impl Drop for vtkSelection { #[test] fn test_vtkSelection_create_drop() { let obj = vtkSelection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSelection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a node in a vtkSelection the defines the selection criteria. /// @@ -9589,7 +44550,7 @@ fn test_vtkSelection_create_drop() { /// qualifiers, and information. The core properties must be specified other wise the /// vtkSelectionNode is not considered valid. These are `FIELD_TYPE` and /// `CONTENT_TYPE`. `FIELD_TYPE` defines what kinds of entities are being selected. -/// Since selections are used to select items in a data-object, these correspond to +/// Since selections are used select items in a data-object, these correspond to /// things like cells, points, nodes, edges, rows, etc. Supported FIELD_TYPE /// values are defined in `vtkSelectionNode::SelectionField`. `CONTENT_TYPE` /// defines the how the selection is described. Supported values are @@ -9622,7 +44583,7 @@ fn test_vtkSelection_create_drop() { /// using vtkDataSetAttributes API. Since global ids are expected to be unique /// for that element type over the entire dataset, it's a convenient way of /// defining selections. For this content-type, the selection list must be -/// a single-component, `vtkIdTypeArray` that lists all the globals ids for +/// to a single-component, `vtkIdTypeArray` that lists all the globals ids for /// the selected elements. /// /// * `vtkSelectionNode::PEDIGREEIDS`: similar to `GLOBALIDS` except uses @@ -9647,14 +44608,14 @@ fn test_vtkSelection_create_drop() { /// `BLOCK_SELECTORS`, `PROCESS_ID` etc. are needed to correctly identify the /// chosen element(s) in case of composite or distributed datasets. /// -/// * `vtkSelectionNode::FRUSTUM`: this type is used to define a frustum in world +/// * `vtkSelectionNode::FRUSTUM: this type is used to define a frustum in world /// coordinates that identifies the selected elements. In this case, the /// selection list is a vtkDoubleArray with 32 values specifying the 8 frustum /// corners in homogeneous world coordinates. /// /// * `vtkSelectionNode::LOCATIONS`: this is used to select points (or cells) /// near (or containing) specified locations. The selection list is a -/// 3-component vtkDoubleArray with coordinates for locations of interest. +/// 3-compnent vtkDoubleArray with coordinates for locations of interest. /// /// * `vtkSelectionNode::THRESHOLDS`: this type is used to define a selection based /// on array value ranges. This is akin to thresholding. All elements with values in @@ -9771,22 +44732,13 @@ fn test_vtkSelection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSelectionNode(*mut core::ffi::c_void); impl vtkSelectionNode { - /// Creates a new [vtkSelectionNode] wrapped inside `vtkNew` + /// Creates a new [vtkSelectionNode] via `vtkSelectionNode::New()` #[doc(alias = "vtkSelectionNode")] pub fn new() -> Self { unsafe extern "C" { fn vtkSelectionNode_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSelectionNode_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSelectionNode_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSelectionNode_get_ptr(self.0) } + Self(unsafe { vtkSelectionNode_new() }) } } impl std::default::Default for vtkSelectionNode { @@ -9806,12 +44758,8 @@ impl Drop for vtkSelectionNode { #[test] fn test_vtkSelectionNode_create_drop() { let obj = vtkSelectionNode::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSelectionNode(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper class to perform cell tessellation /// @@ -9843,22 +44791,13 @@ fn test_vtkSelectionNode_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSimpleCellTessellator(*mut core::ffi::c_void); impl vtkSimpleCellTessellator { - /// Creates a new [vtkSimpleCellTessellator] wrapped inside `vtkNew` + /// Creates a new [vtkSimpleCellTessellator] via `vtkSimpleCellTessellator::New()` #[doc(alias = "vtkSimpleCellTessellator")] pub fn new() -> Self { unsafe extern "C" { fn vtkSimpleCellTessellator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSimpleCellTessellator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSimpleCellTessellator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSimpleCellTessellator_get_ptr(self.0) } + Self(unsafe { vtkSimpleCellTessellator_new() }) } } impl std::default::Default for vtkSimpleCellTessellator { @@ -9878,12 +44817,8 @@ impl Drop for vtkSimpleCellTessellator { #[test] fn test_vtkSimpleCellTessellator_create_drop() { let obj = vtkSimpleCellTessellator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSimpleCellTessellator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Objects that compute /// @@ -9901,22 +44836,13 @@ fn test_vtkSimpleCellTessellator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSmoothErrorMetric(*mut core::ffi::c_void); impl vtkSmoothErrorMetric { - /// Creates a new [vtkSmoothErrorMetric] wrapped inside `vtkNew` + /// Creates a new [vtkSmoothErrorMetric] via `vtkSmoothErrorMetric::New()` #[doc(alias = "vtkSmoothErrorMetric")] pub fn new() -> Self { unsafe extern "C" { fn vtkSmoothErrorMetric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSmoothErrorMetric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSmoothErrorMetric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSmoothErrorMetric_get_ptr(self.0) } + Self(unsafe { vtkSmoothErrorMetric_new() }) } } impl std::default::Default for vtkSmoothErrorMetric { @@ -9936,12 +44862,8 @@ impl Drop for vtkSmoothErrorMetric { #[test] fn test_vtkSmoothErrorMetric_create_drop() { let obj = vtkSmoothErrorMetric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSmoothErrorMetric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// provides a method for sorting field data /// @@ -9971,22 +44893,13 @@ fn test_vtkSmoothErrorMetric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSortFieldData(*mut core::ffi::c_void); impl vtkSortFieldData { - /// Creates a new [vtkSortFieldData] wrapped inside `vtkNew` + /// Creates a new [vtkSortFieldData] via `vtkSortFieldData::New()` #[doc(alias = "vtkSortFieldData")] pub fn new() -> Self { unsafe extern "C" { fn vtkSortFieldData_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSortFieldData_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSortFieldData_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSortFieldData_get_ptr(self.0) } + Self(unsafe { vtkSortFieldData_new() }) } } impl std::default::Default for vtkSortFieldData { @@ -10006,12 +44919,8 @@ impl Drop for vtkSortFieldData { #[test] fn test_vtkSortFieldData_create_drop() { let obj = vtkSortFieldData::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSortFieldData(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a sphere /// @@ -10023,22 +44932,13 @@ fn test_vtkSortFieldData_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSphere(*mut core::ffi::c_void); impl vtkSphere { - /// Creates a new [vtkSphere] wrapped inside `vtkNew` + /// Creates a new [vtkSphere] via `vtkSphere::New()` #[doc(alias = "vtkSphere")] pub fn new() -> Self { unsafe extern "C" { fn vtkSphere_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSphere_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSphere_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSphere_get_ptr(self.0) } + Self(unsafe { vtkSphere_new() }) } } impl std::default::Default for vtkSphere { @@ -10058,12 +44958,8 @@ impl Drop for vtkSphere { #[test] fn test_vtkSphere_create_drop() { let obj = vtkSphere::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSphere(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a set of spheres /// @@ -10082,22 +44978,13 @@ fn test_vtkSphere_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSpheres(*mut core::ffi::c_void); impl vtkSpheres { - /// Creates a new [vtkSpheres] wrapped inside `vtkNew` + /// Creates a new [vtkSpheres] via `vtkSpheres::New()` #[doc(alias = "vtkSpheres")] pub fn new() -> Self { unsafe extern "C" { fn vtkSpheres_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSpheres_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSpheres_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSpheres_get_ptr(self.0) } + Self(unsafe { vtkSpheres_new() }) } } impl std::default::Default for vtkSpheres { @@ -10117,112 +45004,8 @@ impl Drop for vtkSpheres { #[test] fn test_vtkSpheres_create_drop() { let obj = vtkSpheres::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); - drop(obj); - let new_obj = vtkSpheres(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); -} -/// Traverse a collection of points in spherical ordering. -/// -/// -/// -/// vtkSphericalPointIterator is a state-based iterator for traversing a set -/// of points (i.e., a neighborhood of points) in a dataset, providing a point -/// traversal order across user-defined "axes" which span a 2D or 3D space -/// (typically a circle or sphere). The points along each axes may be sorted -/// in increasing radial order. To define the points, specify a dataset (i.e., -/// its associated points, whether the points are represented implicitly or -/// explicitly) and an associated neighborhood over which to iterate. Methods -/// for iterating over the points are provided. -/// -/// For example, consider the axes of iteration to be the four rays emanating -/// from the center of a square and passing through the center of each of the -/// four edges of the square. Points to be iterated over are associated (using -/// a dot product) with each of the four axes, and then can be sorted along -/// each axis. Then the order of iteration is then: (axis0,pt0), (axis1,pt0), -/// (axis2,pt0), (axis3,pt0), (axis0,pt1), (axis1,pt1), (axis2,pt1), -/// (axis3,pt1), (axis0,pt2), (axis1,pt2), (axis2,pt2), (axis3,pt2), and so on -/// in a "spiraling" fashion until all points are visited. Thus the order of -/// visitation is: iteration i visits all N axes in order, returning the jth -/// point sorted along each of the N axes (i.e., i increases the fastest). -/// Alternatively, methods exist to randomly access points, or points -/// associated with an axes, so that custom iteration methods can be defined. -/// -/// The iterator can be defined with any number of axes (defined by 3D -/// vectors). The axes must not be coincident, and typically are equally -/// spaced from one another. The order which the axes are defined determines -/// the order in which the axes (and hence the points) are traversed. So for -/// example, in a 2D sphere, four axes in the (-x,+x,-y,+y) directions would -/// provide a "ping pong" iteration, while four axes ordered in the -/// (+x,+y,-x,-y) directions would provide a counterclockwise rotation -/// iteration. -/// -/// The iterator provides thread-safe iteration of dataset points. It supports -/// both random and forward iteration. -/// -/// @warning -/// The behavior of the iterator depends on the ordering of the iteration -/// axes. It is possible to obtain a wide variety of iteration patterns -/// depending on these axes. For example, if only one axis is defined, then a -/// "linear" pattern is possible (i.e., visiting points in the half space -/// defined by the vector); if two axes, then a "diagonal" iteration pattern; -/// and so on. Note that points are sorted along the iteration axes depending -/// on the their projection onto them (e.g., using the dot product). Because -/// only points with positive projection are associated with an axis, it is -/// possible that some points in the neighborhood will not be processed (i.e., -/// if a point in the neighborhood does not positively project onto any of the -/// axes, then it will not be iterated over). Thus if all points are to be -/// iterated over, then the axes must form a basis which covers all points -/// using positive projections. -/// -/// @sa -/// vtkVoronoi2D vtkVoronoi3D vtkStaticPointLocator vtkPointLocator -#[allow(non_camel_case_types)] -pub struct vtkSphericalPointIterator(*mut core::ffi::c_void); -impl vtkSphericalPointIterator { - /// Creates a new [vtkSphericalPointIterator] wrapped inside `vtkNew` - #[doc(alias = "vtkSphericalPointIterator")] - pub fn new() -> Self { - unsafe extern "C" { - fn vtkSphericalPointIterator_new() -> *mut core::ffi::c_void; - } - Self(unsafe { &mut *vtkSphericalPointIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSphericalPointIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSphericalPointIterator_get_ptr(self.0) } - } -} -impl std::default::Default for vtkSphericalPointIterator { - fn default() -> Self { - Self::new() - } -} -impl Drop for vtkSphericalPointIterator { - fn drop(&mut self) { - unsafe extern "C" { - fn vtkSphericalPointIterator_destructor(sself: *mut core::ffi::c_void); - } - unsafe { vtkSphericalPointIterator_destructor(self.0) } - self.0 = core::ptr::null_mut(); - } -} -#[test] -fn test_vtkSphericalPointIterator_create_drop() { - let obj = vtkSphericalPointIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSphericalPointIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// object represents upward pointers from points /// @@ -10252,22 +45035,13 @@ fn test_vtkSphericalPointIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStaticCellLinks(*mut core::ffi::c_void); impl vtkStaticCellLinks { - /// Creates a new [vtkStaticCellLinks] wrapped inside `vtkNew` + /// Creates a new [vtkStaticCellLinks] via `vtkStaticCellLinks::New()` #[doc(alias = "vtkStaticCellLinks")] pub fn new() -> Self { unsafe extern "C" { fn vtkStaticCellLinks_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStaticCellLinks_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStaticCellLinks_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStaticCellLinks_get_ptr(self.0) } + Self(unsafe { vtkStaticCellLinks_new() }) } } impl std::default::Default for vtkStaticCellLinks { @@ -10287,12 +45061,8 @@ impl Drop for vtkStaticCellLinks { #[test] fn test_vtkStaticCellLinks_create_drop() { let obj = vtkStaticCellLinks::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStaticCellLinks(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// perform fast cell location operations /// @@ -10307,43 +45077,25 @@ fn test_vtkStaticCellLinks_create_drop() { /// (i.e., incremental cell insertion is not supported). /// /// @warning -/// vtkStaticCellLocator utilizes the following parent class parameters: -/// - Automatic (default true) -/// - NumberOfCellsPerNode (default 10) -/// - UseExistingSearchStructure (default false) -/// -/// vtkStaticCellLocator does NOT utilize the following parameters: -/// - CacheCellBounds (always cached) -/// - Tolerance -/// - Level -/// - MaxLevel -/// - RetainCellLists -/// -/// @warning /// This class is templated. It may run slower than serial execution if the code /// is not optimized during compilation. Build in Release or ReleaseWithDebugInfo. /// +/// @warning +/// This class *always* caches cell bounds. +/// /// @sa -/// vtkAbstractCellLocator vtkCellLocator vtkCellTreeLocator vtkModifiedBSPTree vtkOBBTree +/// vtkLocator vakAbstractCellLocator vtkCellLocator vtkCellTreeLocator +/// vtkModifiedBSPTree #[allow(non_camel_case_types)] pub struct vtkStaticCellLocator(*mut core::ffi::c_void); impl vtkStaticCellLocator { - /// Creates a new [vtkStaticCellLocator] wrapped inside `vtkNew` + /// Creates a new [vtkStaticCellLocator] via `vtkStaticCellLocator::New()` #[doc(alias = "vtkStaticCellLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkStaticCellLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStaticCellLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStaticCellLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStaticCellLocator_get_ptr(self.0) } + Self(unsafe { vtkStaticCellLocator_new() }) } } impl std::default::Default for vtkStaticCellLocator { @@ -10363,12 +45115,8 @@ impl Drop for vtkStaticCellLocator { #[test] fn test_vtkStaticCellLocator_create_drop() { let obj = vtkStaticCellLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStaticCellLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// quickly locate points in 3-space /// @@ -10400,34 +45148,18 @@ fn test_vtkStaticCellLocator_create_drop() { /// kd-trees. These are often more efficient for the operations described /// here. /// -/// @warning -/// Frequently vtkStaticPointLocator is used in lieu of vtkPointLocator. -/// They are very similar in terms of algorithmic approach, however -/// vtkStaticCellLocator is threaded and is typically much faster for -/// a large number of points (on the order of 3-5x faster). For small numbers -/// of points, vtkPointLocator is just as fast as vtkStaticPointLocator. -/// /// @sa /// vtkPointLocator vtkCellLocator vtkLocator vtkAbstractPointLocator #[allow(non_camel_case_types)] pub struct vtkStaticPointLocator(*mut core::ffi::c_void); impl vtkStaticPointLocator { - /// Creates a new [vtkStaticPointLocator] wrapped inside `vtkNew` + /// Creates a new [vtkStaticPointLocator] via `vtkStaticPointLocator::New()` #[doc(alias = "vtkStaticPointLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkStaticPointLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStaticPointLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStaticPointLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStaticPointLocator_get_ptr(self.0) } + Self(unsafe { vtkStaticPointLocator_new() }) } } impl std::default::Default for vtkStaticPointLocator { @@ -10447,12 +45179,8 @@ impl Drop for vtkStaticPointLocator { #[test] fn test_vtkStaticPointLocator_create_drop() { let obj = vtkStaticPointLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStaticPointLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// quickly locate points in 2-space /// @@ -10495,22 +45223,13 @@ fn test_vtkStaticPointLocator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStaticPointLocator2D(*mut core::ffi::c_void); impl vtkStaticPointLocator2D { - /// Creates a new [vtkStaticPointLocator2D] wrapped inside `vtkNew` + /// Creates a new [vtkStaticPointLocator2D] via `vtkStaticPointLocator2D::New()` #[doc(alias = "vtkStaticPointLocator2D")] pub fn new() -> Self { unsafe extern "C" { fn vtkStaticPointLocator2D_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStaticPointLocator2D_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStaticPointLocator2D_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStaticPointLocator2D_get_ptr(self.0) } + Self(unsafe { vtkStaticPointLocator2D_new() }) } } impl std::default::Default for vtkStaticPointLocator2D { @@ -10530,12 +45249,8 @@ impl Drop for vtkStaticPointLocator2D { #[test] fn test_vtkStaticPointLocator2D_create_drop() { let obj = vtkStaticPointLocator2D::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStaticPointLocator2D(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// helper class to aid working with structured /// @@ -10548,22 +45263,13 @@ fn test_vtkStaticPointLocator2D_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredExtent(*mut core::ffi::c_void); impl vtkStructuredExtent { - /// Creates a new [vtkStructuredExtent] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredExtent] via `vtkStructuredExtent::New()` #[doc(alias = "vtkStructuredExtent")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredExtent_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredExtent_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredExtent_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredExtent_get_ptr(self.0) } + Self(unsafe { vtkStructuredExtent_new() }) } } impl std::default::Default for vtkStructuredExtent { @@ -10583,12 +45289,8 @@ impl Drop for vtkStructuredExtent { #[test] fn test_vtkStructuredExtent_create_drop() { let obj = vtkStructuredExtent::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredExtent(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// topologically regular array of data /// @@ -10617,22 +45319,13 @@ fn test_vtkStructuredExtent_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredGrid(*mut core::ffi::c_void); impl vtkStructuredGrid { - /// Creates a new [vtkStructuredGrid] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredGrid] via `vtkStructuredGrid::New()` #[doc(alias = "vtkStructuredGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredGrid_get_ptr(self.0) } + Self(unsafe { vtkStructuredGrid_new() }) } } impl std::default::Default for vtkStructuredGrid { @@ -10652,18 +45345,14 @@ impl Drop for vtkStructuredGrid { #[test] fn test_vtkStructuredGrid_create_drop() { let obj = vtkStructuredGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A subclass of ImageData. /// /// /// StructuredPoints is a subclass of ImageData that requires the data extent -/// to exactly match the update extent. Normal image data allows that the +/// to exactly match the update extent. Normall image data allows that the /// data extent may be larger than the update extent. /// StructuredPoints also defines the origin differently that vtkImageData. /// For structured points the origin is the location of first point. @@ -10673,22 +45362,13 @@ fn test_vtkStructuredGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredPoints(*mut core::ffi::c_void); impl vtkStructuredPoints { - /// Creates a new [vtkStructuredPoints] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredPoints] via `vtkStructuredPoints::New()` #[doc(alias = "vtkStructuredPoints")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredPoints_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredPoints_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredPoints_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredPoints_get_ptr(self.0) } + Self(unsafe { vtkStructuredPoints_new() }) } } impl std::default::Default for vtkStructuredPoints { @@ -10708,12 +45388,8 @@ impl Drop for vtkStructuredPoints { #[test] fn test_vtkStructuredPoints_create_drop() { let obj = vtkStructuredPoints::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredPoints(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of structured points data objects /// @@ -10724,22 +45400,13 @@ fn test_vtkStructuredPoints_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredPointsCollection(*mut core::ffi::c_void); impl vtkStructuredPointsCollection { - /// Creates a new [vtkStructuredPointsCollection] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredPointsCollection] via `vtkStructuredPointsCollection::New()` #[doc(alias = "vtkStructuredPointsCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredPointsCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredPointsCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredPointsCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredPointsCollection_get_ptr(self.0) } + Self(unsafe { vtkStructuredPointsCollection_new() }) } } impl std::default::Default for vtkStructuredPointsCollection { @@ -10759,12 +45426,8 @@ impl Drop for vtkStructuredPointsCollection { #[test] fn test_vtkStructuredPointsCollection_create_drop() { let obj = vtkStructuredPointsCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredPointsCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// implicit function for a Superquadric /// @@ -10792,22 +45455,13 @@ fn test_vtkStructuredPointsCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSuperquadric(*mut core::ffi::c_void); impl vtkSuperquadric { - /// Creates a new [vtkSuperquadric] wrapped inside `vtkNew` + /// Creates a new [vtkSuperquadric] via `vtkSuperquadric::New()` #[doc(alias = "vtkSuperquadric")] pub fn new() -> Self { unsafe extern "C" { fn vtkSuperquadric_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSuperquadric_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSuperquadric_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSuperquadric_get_ptr(self.0) } + Self(unsafe { vtkSuperquadric_new() }) } } impl std::default::Default for vtkSuperquadric { @@ -10827,12 +45481,8 @@ impl Drop for vtkSuperquadric { #[test] fn test_vtkSuperquadric_create_drop() { let obj = vtkSuperquadric::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSuperquadric(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A table, which contains similar-typed columns of data /// @@ -10844,11 +45494,6 @@ fn test_vtkSuperquadric_create_drop() { /// has the same number of entries, and provides row access (using vtkVariantArray) /// and single entry access (using vtkVariant). /// -/// Inserting or removing rows via the class API preserves existing table data where possible. -/// -/// The "RemoveRow*" and SetNumberOfRows() operations will not release memory. Call on SqueezeRows() -/// to achieve this after performing the operations. -/// /// The field data inherited from vtkDataObject may be used to store metadata /// related to the table. /// @@ -10870,20 +45515,13 @@ fn test_vtkSuperquadric_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTable(*mut core::ffi::c_void); impl vtkTable { - /// Creates a new [vtkTable] wrapped inside `vtkNew` + /// Creates a new [vtkTable] via `vtkTable::New()` #[doc(alias = "vtkTable")] pub fn new() -> Self { unsafe extern "C" { fn vtkTable_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTable_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTable_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkTable_get_ptr(self.0) } + Self(unsafe { vtkTable_new() }) } } impl std::default::Default for vtkTable { @@ -10903,12 +45541,8 @@ impl Drop for vtkTable { #[test] fn test_vtkTable_create_drop() { let obj = vtkTable::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTable(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a tetrahedron /// @@ -10925,20 +45559,13 @@ fn test_vtkTable_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTetra(*mut core::ffi::c_void); impl vtkTetra { - /// Creates a new [vtkTetra] wrapped inside `vtkNew` + /// Creates a new [vtkTetra] via `vtkTetra::New()` #[doc(alias = "vtkTetra")] pub fn new() -> Self { unsafe extern "C" { fn vtkTetra_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTetra_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTetra_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkTetra_get_ptr(self.0) } + Self(unsafe { vtkTetra_new() }) } } impl std::default::Default for vtkTetra { @@ -10958,12 +45585,8 @@ impl Drop for vtkTetra { #[test] fn test_vtkTetra_create_drop() { let obj = vtkTetra::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTetra(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A rooted tree data structure. /// @@ -10991,20 +45614,13 @@ fn test_vtkTetra_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTree(*mut core::ffi::c_void); impl vtkTree { - /// Creates a new [vtkTree] wrapped inside `vtkNew` + /// Creates a new [vtkTree] via `vtkTree::New()` #[doc(alias = "vtkTree")] pub fn new() -> Self { unsafe extern "C" { fn vtkTree_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTree_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTree_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkTree_get_ptr(self.0) } + Self(unsafe { vtkTree_new() }) } } impl std::default::Default for vtkTree { @@ -11024,12 +45640,8 @@ impl Drop for vtkTree { #[test] fn test_vtkTree_create_drop() { let obj = vtkTree::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTree(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// breadth first search iterator through a vtkTree /// @@ -11046,22 +45658,13 @@ fn test_vtkTree_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTreeBFSIterator(*mut core::ffi::c_void); impl vtkTreeBFSIterator { - /// Creates a new [vtkTreeBFSIterator] wrapped inside `vtkNew` + /// Creates a new [vtkTreeBFSIterator] via `vtkTreeBFSIterator::New()` #[doc(alias = "vtkTreeBFSIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkTreeBFSIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTreeBFSIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTreeBFSIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTreeBFSIterator_get_ptr(self.0) } + Self(unsafe { vtkTreeBFSIterator_new() }) } } impl std::default::Default for vtkTreeBFSIterator { @@ -11081,12 +45684,8 @@ impl Drop for vtkTreeBFSIterator { #[test] fn test_vtkTreeBFSIterator_create_drop() { let obj = vtkTreeBFSIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTreeBFSIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// depth first iterator through a vtkGraph /// @@ -11106,22 +45705,13 @@ fn test_vtkTreeBFSIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTreeDFSIterator(*mut core::ffi::c_void); impl vtkTreeDFSIterator { - /// Creates a new [vtkTreeDFSIterator] wrapped inside `vtkNew` + /// Creates a new [vtkTreeDFSIterator] via `vtkTreeDFSIterator::New()` #[doc(alias = "vtkTreeDFSIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkTreeDFSIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTreeDFSIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTreeDFSIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTreeDFSIterator_get_ptr(self.0) } + Self(unsafe { vtkTreeDFSIterator_new() }) } } impl std::default::Default for vtkTreeDFSIterator { @@ -11141,12 +45731,8 @@ impl Drop for vtkTreeDFSIterator { #[test] fn test_vtkTreeDFSIterator_create_drop() { let obj = vtkTreeDFSIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTreeDFSIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// cell represents a parabolic, 27-node isoparametric hexahedron /// @@ -11204,22 +45790,13 @@ fn test_vtkTreeDFSIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTriQuadraticHexahedron(*mut core::ffi::c_void); impl vtkTriQuadraticHexahedron { - /// Creates a new [vtkTriQuadraticHexahedron] wrapped inside `vtkNew` + /// Creates a new [vtkTriQuadraticHexahedron] via `vtkTriQuadraticHexahedron::New()` #[doc(alias = "vtkTriQuadraticHexahedron")] pub fn new() -> Self { unsafe extern "C" { fn vtkTriQuadraticHexahedron_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTriQuadraticHexahedron_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTriQuadraticHexahedron_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTriQuadraticHexahedron_get_ptr(self.0) } + Self(unsafe { vtkTriQuadraticHexahedron_new() }) } } impl std::default::Default for vtkTriQuadraticHexahedron { @@ -11239,14 +45816,10 @@ impl Drop for vtkTriQuadraticHexahedron { #[test] fn test_vtkTriQuadraticHexahedron_create_drop() { let obj = vtkTriQuadraticHexahedron::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTriQuadraticHexahedron(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// cell represents a parabolic, 19-node isoparametric pyramid +/// cell represents a parabolic, 13-node isoparametric pyramid /// /// /// vtkTriQuadraticPyramid is a concrete implementation of vtkNonLinearCell to @@ -11321,22 +45894,13 @@ fn test_vtkTriQuadraticHexahedron_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTriQuadraticPyramid(*mut core::ffi::c_void); impl vtkTriQuadraticPyramid { - /// Creates a new [vtkTriQuadraticPyramid] wrapped inside `vtkNew` + /// Creates a new [vtkTriQuadraticPyramid] via `vtkTriQuadraticPyramid::New()` #[doc(alias = "vtkTriQuadraticPyramid")] pub fn new() -> Self { unsafe extern "C" { fn vtkTriQuadraticPyramid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTriQuadraticPyramid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTriQuadraticPyramid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTriQuadraticPyramid_get_ptr(self.0) } + Self(unsafe { vtkTriQuadraticPyramid_new() }) } } impl std::default::Default for vtkTriQuadraticPyramid { @@ -11356,12 +45920,8 @@ impl Drop for vtkTriQuadraticPyramid { #[test] fn test_vtkTriQuadraticPyramid_create_drop() { let obj = vtkTriQuadraticPyramid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTriQuadraticPyramid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a triangle /// @@ -11371,22 +45931,13 @@ fn test_vtkTriQuadraticPyramid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTriangle(*mut core::ffi::c_void); impl vtkTriangle { - /// Creates a new [vtkTriangle] wrapped inside `vtkNew` + /// Creates a new [vtkTriangle] via `vtkTriangle::New()` #[doc(alias = "vtkTriangle")] pub fn new() -> Self { unsafe extern "C" { fn vtkTriangle_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTriangle_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTriangle_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTriangle_get_ptr(self.0) } + Self(unsafe { vtkTriangle_new() }) } } impl std::default::Default for vtkTriangle { @@ -11406,12 +45957,8 @@ impl Drop for vtkTriangle { #[test] fn test_vtkTriangle_create_drop() { let obj = vtkTriangle::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTriangle(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a triangle strip /// @@ -11425,22 +45972,13 @@ fn test_vtkTriangle_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTriangleStrip(*mut core::ffi::c_void); impl vtkTriangleStrip { - /// Creates a new [vtkTriangleStrip] wrapped inside `vtkNew` + /// Creates a new [vtkTriangleStrip] via `vtkTriangleStrip::New()` #[doc(alias = "vtkTriangleStrip")] pub fn new() -> Self { unsafe extern "C" { fn vtkTriangleStrip_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTriangleStrip_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTriangleStrip_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTriangleStrip_get_ptr(self.0) } + Self(unsafe { vtkTriangleStrip_new() }) } } impl std::default::Default for vtkTriangleStrip { @@ -11460,12 +45998,8 @@ impl Drop for vtkTriangleStrip { #[test] fn test_vtkTriangleStrip_create_drop() { let obj = vtkTriangleStrip::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTriangleStrip(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// An undirected graph. /// @@ -11489,22 +46023,13 @@ fn test_vtkTriangleStrip_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUndirectedGraph(*mut core::ffi::c_void); impl vtkUndirectedGraph { - /// Creates a new [vtkUndirectedGraph] wrapped inside `vtkNew` + /// Creates a new [vtkUndirectedGraph] via `vtkUndirectedGraph::New()` #[doc(alias = "vtkUndirectedGraph")] pub fn new() -> Self { unsafe extern "C" { fn vtkUndirectedGraph_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUndirectedGraph_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUndirectedGraph_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUndirectedGraph_get_ptr(self.0) } + Self(unsafe { vtkUndirectedGraph_new() }) } } impl std::default::Default for vtkUndirectedGraph { @@ -11524,12 +46049,8 @@ impl Drop for vtkUndirectedGraph { #[test] fn test_vtkUndirectedGraph_create_drop() { let obj = vtkUndirectedGraph::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUndirectedGraph(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// image data with blanking /// @@ -11539,22 +46060,13 @@ fn test_vtkUndirectedGraph_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformGrid(*mut core::ffi::c_void); impl vtkUniformGrid { - /// Creates a new [vtkUniformGrid] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGrid] via `vtkUniformGrid::New()` #[doc(alias = "vtkUniformGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGrid_get_ptr(self.0) } + Self(unsafe { vtkUniformGrid_new() }) } } impl std::default::Default for vtkUniformGrid { @@ -11574,39 +46086,20 @@ impl Drop for vtkUniformGrid { #[test] fn test_vtkUniformGrid_create_drop() { let obj = vtkUniformGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } -/// a concrete implementation of vtkCompositeDataSet -/// /// -/// vtkUniformGridAMR is an AMR (hierarchical) composite dataset that holds vtkUniformGrids. -/// -/// @sa -/// vtkUniformGridAMRDataIterator #[allow(non_camel_case_types)] pub struct vtkUniformGridAMR(*mut core::ffi::c_void); impl vtkUniformGridAMR { - /// Creates a new [vtkUniformGridAMR] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGridAMR] via `vtkUniformGridAMR::New()` #[doc(alias = "vtkUniformGridAMR")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGridAMR_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGridAMR_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGridAMR_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGridAMR_get_ptr(self.0) } + Self(unsafe { vtkUniformGridAMR_new() }) } } impl std::default::Default for vtkUniformGridAMR { @@ -11626,12 +46119,8 @@ impl Drop for vtkUniformGridAMR { #[test] fn test_vtkUniformGridAMR_create_drop() { let obj = vtkUniformGridAMR::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGridAMR(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// subclass of vtkCompositeDataIterator /// @@ -11639,22 +46128,13 @@ fn test_vtkUniformGridAMR_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformGridAMRDataIterator(*mut core::ffi::c_void); impl vtkUniformGridAMRDataIterator { - /// Creates a new [vtkUniformGridAMRDataIterator] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGridAMRDataIterator] via `vtkUniformGridAMRDataIterator::New()` #[doc(alias = "vtkUniformGridAMRDataIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGridAMRDataIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGridAMRDataIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGridAMRDataIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGridAMRDataIterator_get_ptr(self.0) } + Self(unsafe { vtkUniformGridAMRDataIterator_new() }) } } impl std::default::Default for vtkUniformGridAMRDataIterator { @@ -11674,12 +46154,8 @@ impl Drop for vtkUniformGridAMRDataIterator { #[test] fn test_vtkUniformGridAMRDataIterator_create_drop() { let obj = vtkUniformGridAMRDataIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGridAMRDataIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A specifalized type of vtkHyperTreeGrid for the case /// @@ -11696,22 +46172,13 @@ fn test_vtkUniformGridAMRDataIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformHyperTreeGrid(*mut core::ffi::c_void); impl vtkUniformHyperTreeGrid { - /// Creates a new [vtkUniformHyperTreeGrid] wrapped inside `vtkNew` + /// Creates a new [vtkUniformHyperTreeGrid] via `vtkUniformHyperTreeGrid::New()` #[doc(alias = "vtkUniformHyperTreeGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformHyperTreeGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformHyperTreeGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformHyperTreeGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformHyperTreeGrid_get_ptr(self.0) } + Self(unsafe { vtkUniformHyperTreeGrid_new() }) } } impl std::default::Default for vtkUniformHyperTreeGrid { @@ -11731,12 +46198,8 @@ impl Drop for vtkUniformHyperTreeGrid { #[test] fn test_vtkUniformHyperTreeGrid_create_drop() { let obj = vtkUniformHyperTreeGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformHyperTreeGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// dataset represents arbitrary combinations of /// @@ -11751,22 +46214,13 @@ fn test_vtkUniformHyperTreeGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnstructuredGrid(*mut core::ffi::c_void); impl vtkUnstructuredGrid { - /// Creates a new [vtkUnstructuredGrid] wrapped inside `vtkNew` + /// Creates a new [vtkUnstructuredGrid] via `vtkUnstructuredGrid::New()` #[doc(alias = "vtkUnstructuredGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnstructuredGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnstructuredGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnstructuredGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnstructuredGrid_get_ptr(self.0) } + Self(unsafe { vtkUnstructuredGrid_new() }) } } impl std::default::Default for vtkUnstructuredGrid { @@ -11786,12 +46240,8 @@ impl Drop for vtkUnstructuredGrid { #[test] fn test_vtkUnstructuredGrid_create_drop() { let obj = vtkUnstructuredGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnstructuredGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Implementation of vtkCellIterator /// @@ -11799,22 +46249,13 @@ fn test_vtkUnstructuredGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnstructuredGridCellIterator(*mut core::ffi::c_void); impl vtkUnstructuredGridCellIterator { - /// Creates a new [vtkUnstructuredGridCellIterator] wrapped inside `vtkNew` + /// Creates a new [vtkUnstructuredGridCellIterator] via `vtkUnstructuredGridCellIterator::New()` #[doc(alias = "vtkUnstructuredGridCellIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnstructuredGridCellIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnstructuredGridCellIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnstructuredGridCellIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnstructuredGridCellIterator_get_ptr(self.0) } + Self(unsafe { vtkUnstructuredGridCellIterator_new() }) } } impl std::default::Default for vtkUnstructuredGridCellIterator { @@ -11834,12 +46275,8 @@ impl Drop for vtkUnstructuredGridCellIterator { #[test] fn test_vtkUnstructuredGridCellIterator_create_drop() { let obj = vtkUnstructuredGridCellIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnstructuredGridCellIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a 3D point /// @@ -11848,22 +46285,13 @@ fn test_vtkUnstructuredGridCellIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVertex(*mut core::ffi::c_void); impl vtkVertex { - /// Creates a new [vtkVertex] wrapped inside `vtkNew` + /// Creates a new [vtkVertex] via `vtkVertex::New()` #[doc(alias = "vtkVertex")] pub fn new() -> Self { unsafe extern "C" { fn vtkVertex_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVertex_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVertex_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVertex_get_ptr(self.0) } + Self(unsafe { vtkVertex_new() }) } } impl std::default::Default for vtkVertex { @@ -11883,12 +46311,8 @@ impl Drop for vtkVertex { #[test] fn test_vtkVertex_create_drop() { let obj = vtkVertex::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVertex(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Iterates all vertices in a graph. /// @@ -11904,22 +46328,13 @@ fn test_vtkVertex_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVertexListIterator(*mut core::ffi::c_void); impl vtkVertexListIterator { - /// Creates a new [vtkVertexListIterator] wrapped inside `vtkNew` + /// Creates a new [vtkVertexListIterator] via `vtkVertexListIterator::New()` #[doc(alias = "vtkVertexListIterator")] pub fn new() -> Self { unsafe extern "C" { fn vtkVertexListIterator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVertexListIterator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVertexListIterator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkVertexListIterator_get_ptr(self.0) } + Self(unsafe { vtkVertexListIterator_new() }) } } impl std::default::Default for vtkVertexListIterator { @@ -11939,12 +46354,8 @@ impl Drop for vtkVertexListIterator { #[test] fn test_vtkVertexListIterator_create_drop() { let obj = vtkVertexListIterator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVertexListIterator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a cell that represents a 3D orthogonal parallelepiped /// @@ -11959,20 +46370,13 @@ fn test_vtkVertexListIterator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkVoxel(*mut core::ffi::c_void); impl vtkVoxel { - /// Creates a new [vtkVoxel] wrapped inside `vtkNew` + /// Creates a new [vtkVoxel] via `vtkVoxel::New()` #[doc(alias = "vtkVoxel")] pub fn new() -> Self { unsafe extern "C" { fn vtkVoxel_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkVoxel_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkVoxel_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkVoxel_get_ptr(self.0) } + Self(unsafe { vtkVoxel_new() }) } } impl std::default::Default for vtkVoxel { @@ -11992,12 +46396,8 @@ impl Drop for vtkVoxel { #[test] fn test_vtkVoxel_create_drop() { let obj = vtkVoxel::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkVoxel(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a 3D cell that represents a linear wedge /// @@ -12015,20 +46415,13 @@ fn test_vtkVoxel_create_drop() { #[allow(non_camel_case_types)] pub struct vtkWedge(*mut core::ffi::c_void); impl vtkWedge { - /// Creates a new [vtkWedge] wrapped inside `vtkNew` + /// Creates a new [vtkWedge] via `vtkWedge::New()` #[doc(alias = "vtkWedge")] pub fn new() -> Self { unsafe extern "C" { fn vtkWedge_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkWedge_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkWedge_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkWedge_get_ptr(self.0) } + Self(unsafe { vtkWedge_new() }) } } impl std::default::Default for vtkWedge { @@ -12048,12 +46441,8 @@ impl Drop for vtkWedge { #[test] fn test_vtkWedge_create_drop() { let obj = vtkWedge::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkWedge(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Represents an XML element and those nested inside. /// @@ -12068,22 +46457,13 @@ fn test_vtkWedge_create_drop() { #[allow(non_camel_case_types)] pub struct vtkXMLDataElement(*mut core::ffi::c_void); impl vtkXMLDataElement { - /// Creates a new [vtkXMLDataElement] wrapped inside `vtkNew` + /// Creates a new [vtkXMLDataElement] via `vtkXMLDataElement::New()` #[doc(alias = "vtkXMLDataElement")] pub fn new() -> Self { unsafe extern "C" { fn vtkXMLDataElement_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkXMLDataElement_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkXMLDataElement_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkXMLDataElement_get_ptr(self.0) } + Self(unsafe { vtkXMLDataElement_new() }) } } impl std::default::Default for vtkXMLDataElement { @@ -12103,10 +46483,6 @@ impl Drop for vtkXMLDataElement { #[test] fn test_vtkXMLDataElement_create_drop() { let obj = vtkXMLDataElement::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkXMLDataElement(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonExecutionModel.rs b/vtk-rs-9.1/src/vtkCommonExecutionModel.rs index 6846309..a92bc78 100644 --- a/vtk-rs-9.1/src/vtkCommonExecutionModel.rs +++ b/vtk-rs-9.1/src/vtkCommonExecutionModel.rs @@ -1,3 +1,5861 @@ +pub trait VtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn has_executive(&mut self) -> core::ffi::c_int; + fn get_executive(&mut self) -> *mut core::ffi::c_void; + fn set_executive(&mut self, executive: *mut core::ffi::c_void) -> (); + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn modify_request( + &mut self, + request: *mut core::ffi::c_void, + when: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_input_port_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_output_port_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_information(&mut self) -> *mut core::ffi::c_void; + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_number_of_input_ports(&mut self) -> core::ffi::c_int; + fn get_number_of_output_ports(&mut self) -> core::ffi::c_int; + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn set_abort_execute(&mut self, _arg: core::ffi::c_int) -> (); + fn get_abort_execute(&mut self) -> core::ffi::c_int; + fn abort_execute_on(&mut self) -> (); + fn abort_execute_off(&mut self) -> (); + fn get_progress(&mut self) -> core::ffi::c_double; + fn set_progress(&mut self, p0: core::ffi::c_double) -> (); + fn update_progress(&mut self, amount: core::ffi::c_double) -> (); + fn set_progress_shift_scale( + &mut self, + shift: core::ffi::c_double, + scale: core::ffi::c_double, + ) -> (); + fn get_progress_shift(&mut self) -> core::ffi::c_double; + fn get_progress_scale(&mut self) -> core::ffi::c_double; + fn set_progress_text(&mut self, ptext: &str) -> (); + fn get_error_code(&mut self) -> core::ffi::c_ulong; + fn input_is_optional(&mut self) -> *mut core::ffi::c_void; + fn input_is_repeatable(&mut self) -> *mut core::ffi::c_void; + fn input_required_fields(&mut self) -> *mut core::ffi::c_void; + fn input_required_data_type(&mut self) -> *mut core::ffi::c_void; + fn input_arrays_to_process(&mut self) -> *mut core::ffi::c_void; + fn input_port(&mut self) -> *mut core::ffi::c_void; + fn input_connection(&mut self) -> *mut core::ffi::c_void; + fn can_produce_sub_extent(&mut self) -> *mut core::ffi::c_void; + fn can_handle_piece_request(&mut self) -> *mut core::ffi::c_void; + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + name: &str, + ) -> (); + fn get_input_array_information( + &mut self, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn remove_all_inputs(&mut self) -> (); + fn get_output_data_object( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_data_object( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> (); + fn add_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> (); + fn remove_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> (); + fn remove_all_input_connections(&mut self, port: core::ffi::c_int) -> (); + fn set_input_data_object( + &mut self, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> (); + fn add_input_data_object( + &mut self, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> (); + fn get_output_port(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_number_of_input_connections( + &mut self, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_total_number_of_input_connections(&mut self) -> core::ffi::c_int; + fn get_input_connection( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_algorithm( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + algPort: &mut core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_executive( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_information( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_output_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn update(&mut self, port: core::ffi::c_int) -> (); + fn update_information(&mut self) -> (); + fn update_data_object(&mut self) -> (); + fn propagate_update_extent(&mut self) -> (); + fn update_whole_extent(&mut self) -> (); + fn convert_total_input_to_port_connection( + &mut self, + ind: core::ffi::c_int, + port: &mut core::ffi::c_int, + conn: &mut core::ffi::c_int, + ) -> (); + fn set_release_data_flag(&mut self, p0: core::ffi::c_int) -> (); + fn get_release_data_flag(&mut self) -> core::ffi::c_int; + fn release_data_flag_on(&mut self) -> (); + fn release_data_flag_off(&mut self) -> (); + fn update_extent_is_empty( + &mut self, + pinfo: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn set_default_executive_prototype(&mut self, proto: *mut core::ffi::c_void) -> (); + fn get_update_piece(&mut self) -> core::ffi::c_int; + fn get_update_number_of_pieces(&mut self) -> core::ffi::c_int; + fn get_update_ghost_level(&mut self) -> core::ffi::c_int; + fn set_progress_observer(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_progress_observer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkAlgorithmOutput { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_index(&mut self, index: core::ffi::c_int) -> (); + fn get_index(&mut self) -> core::ffi::c_int; + fn get_producer(&mut self) -> *mut core::ffi::c_void; + fn set_producer(&mut self, producer: *mut core::ffi::c_void) -> (); +} +pub trait VtkAnnotationLayersAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkArrayDataAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkCachedStreamingDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_cache_size(&mut self, size: core::ffi::c_int) -> (); + fn get_cache_size(&mut self) -> core::ffi::c_int; +} +pub trait VtkCastToConcrete { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCompositeDataPipeline { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_composite_output_data( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn load_requested_blocks(&mut self) -> *mut core::ffi::c_void; + fn composite_data_meta_data(&mut self) -> *mut core::ffi::c_void; + fn update_composite_indices(&mut self) -> *mut core::ffi::c_void; + fn block_amount_of_detail(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkCompositeDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkDataObjectAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; + fn get_image_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_pipeline_m_time(&mut self) -> core::ffi::c_ulong; + fn set_release_data_flag( + &mut self, + port: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_release_data_flag(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn update_pipeline_m_time(&mut self) -> core::ffi::c_int; + fn update_data_object(&mut self) -> core::ffi::c_int; + fn update_data(&mut self, outputPort: core::ffi::c_int) -> core::ffi::c_int; + fn request_data_object(&mut self) -> *mut core::ffi::c_void; + fn request_information(&mut self) -> *mut core::ffi::c_void; + fn request_data(&mut self) -> *mut core::ffi::c_void; + fn request_data_not_generated(&mut self) -> *mut core::ffi::c_void; + fn release_data(&mut self) -> *mut core::ffi::c_void; + fn data_not_generated(&mut self) -> *mut core::ffi::c_void; + fn new_data_object(&mut self, type_: &str) -> *mut core::ffi::c_void; +} +pub trait VtkDirectedGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkEnsembleSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_member(&mut self, p0: *mut core::ffi::c_void) -> (); + fn remove_all_members(&mut self) -> (); + fn get_number_of_members(&mut self) -> core::ffi::c_uint; + fn set_current_member(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_current_member(&mut self) -> core::ffi::c_uint; + fn set_meta_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn meta_data(&mut self) -> *mut core::ffi::c_void; + fn update_member(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkExecutive { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_algorithm(&mut self) -> *mut core::ffi::c_void; + fn update_information(&mut self) -> core::ffi::c_int; + fn update(&mut self) -> core::ffi::c_int; + fn get_number_of_input_ports(&mut self) -> core::ffi::c_int; + fn get_number_of_output_ports(&mut self) -> core::ffi::c_int; + fn get_number_of_input_connections( + &mut self, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_output_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_information( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_input_executive( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_output_data(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_output_data( + &mut self, + port: core::ffi::c_int, + p1: *mut core::ffi::c_void, + info: *mut core::ffi::c_void, + ) -> (); + fn get_input_data( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_shared_output_information( + &mut self, + outInfoVec: *mut core::ffi::c_void, + ) -> (); + fn register(&mut self, o: *mut core::ffi::c_void) -> (); + fn producer(&mut self) -> *mut core::ffi::c_void; + fn consumers(&mut self) -> *mut core::ffi::c_void; + fn from_output_port(&mut self) -> *mut core::ffi::c_void; + fn algorithm_before_forward(&mut self) -> *mut core::ffi::c_void; + fn algorithm_after_forward(&mut self) -> *mut core::ffi::c_void; + fn algorithm_direction(&mut self) -> *mut core::ffi::c_void; + fn forward_direction(&mut self) -> *mut core::ffi::c_void; + fn keys_to_copy(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkExplicitStructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_explicit_structured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkExtentRCBPartitioner { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_partitions(&mut self, N: core::ffi::c_int) -> (); + fn set_global_extent( + &mut self, + imin: core::ffi::c_int, + imax: core::ffi::c_int, + jmin: core::ffi::c_int, + jmax: core::ffi::c_int, + kmin: core::ffi::c_int, + kmax: core::ffi::c_int, + ) -> (); + fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> (); + fn get_duplicate_nodes(&mut self) -> core::ffi::c_int; + fn duplicate_nodes_on(&mut self) -> (); + fn duplicate_nodes_off(&mut self) -> (); + fn set_number_of_ghost_layers(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int; + fn get_num_extents(&mut self) -> core::ffi::c_int; + fn partition(&mut self) -> (); +} +pub trait VtkExtentSplitter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_extent_source( + &mut self, + id: core::ffi::c_int, + priority: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn remove_extent_source(&mut self, id: core::ffi::c_int) -> (); + fn remove_all_extent_sources(&mut self) -> (); + fn add_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> (); + fn compute_sub_extents(&mut self) -> core::ffi::c_int; + fn get_number_of_sub_extents(&mut self) -> core::ffi::c_int; + fn get_sub_extent_source(&mut self, index: core::ffi::c_int) -> core::ffi::c_int; + fn get_point_mode(&mut self) -> core::ffi::c_int; + fn set_point_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn point_mode_on(&mut self) -> (); + fn point_mode_off(&mut self) -> (); +} +pub trait VtkExtentTranslator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn set_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn set_piece(&mut self, _arg: core::ffi::c_int) -> (); + fn get_piece(&mut self) -> core::ffi::c_int; + fn set_number_of_pieces(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_pieces(&mut self) -> core::ffi::c_int; + fn set_ghost_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_ghost_level(&mut self) -> core::ffi::c_int; + fn piece_to_extent(&mut self) -> core::ffi::c_int; + fn piece_to_extent_by_points(&mut self) -> core::ffi::c_int; + fn set_split_mode_to_block(&mut self) -> (); + fn set_split_mode_to_x_slab(&mut self) -> (); + fn set_split_mode_to_y_slab(&mut self) -> (); + fn set_split_mode_to_z_slab(&mut self) -> (); + fn get_split_mode(&mut self) -> core::ffi::c_int; + fn update_split_mode(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkFilteringInformationKeyManager { + fn register(&mut self, key: *mut core::ffi::c_void) -> (); +} +pub trait VtkGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkHierarchicalBoxDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkHyperTreeGridAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_hyper_tree_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkImageAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_image_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkImageInPlaceFilter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkImageProgressIterator { + fn next_span(&mut self) -> (); + fn is_at_end(&mut self) -> core::ffi::c_int; +} +pub trait VtkImageToStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkImageToStructuredPoints { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_vector_input_data(&mut self, input: *mut core::ffi::c_void) -> (); + fn get_vector_input(&mut self) -> *mut core::ffi::c_void; + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkInformationDataObjectMetaDataKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn copy_default_information( + &mut self, + request: *mut core::ffi::c_void, + fromInfo: *mut core::ffi::c_void, + toInfo: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationExecutivePortKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn set( + &mut self, + info: *mut core::ffi::c_void, + p1: *mut core::ffi::c_void, + p2: core::ffi::c_int, + ) -> (); + fn get_executive(&mut self, info: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn get_port(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get( + &mut self, + info: *mut core::ffi::c_void, + executive: *mut core::ffi::c_void, + port: &mut core::ffi::c_int, + ) -> (); + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationExecutivePortVectorKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn append( + &mut self, + info: *mut core::ffi::c_void, + executive: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> (); + fn remove( + &mut self, + info: *mut core::ffi::c_void, + executive: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> (); + fn length(&mut self, info: *mut core::ffi::c_void) -> core::ffi::c_int; + fn shallow_copy( + &mut self, + from: *mut core::ffi::c_void, + to: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkInformationIntegerRequestKey { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_key(&mut self, name: &str, location: &str) -> *mut core::ffi::c_void; + fn need_to_execute( + &mut self, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> bool; + fn store_meta_data( + &mut self, + request: *mut core::ffi::c_void, + pipelineInfo: *mut core::ffi::c_void, + dobjInfo: *mut core::ffi::c_void, + ) -> (); + fn copy_default_information( + &mut self, + request: *mut core::ffi::c_void, + fromInfo: *mut core::ffi::c_void, + toInfo: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkMoleculeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_molecule_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkMultiBlockDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkMultiTimeStepAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkNonOverlappingAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkOverlappingAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkParallelReader { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_file_name(&mut self, fname: &str) -> (); + fn clear_file_names(&mut self) -> (); + fn get_number_of_file_names(&mut self) -> core::ffi::c_int; + fn get_file_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_current_file_name(&mut self) -> &str; + fn read_meta_data(&mut self, metadata: *mut core::ffi::c_void) -> core::ffi::c_int; + fn read_mesh( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_points( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_arrays( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkPartitionedDataSetAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPartitionedDataSetCollectionAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPassInputTypeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; + fn get_image_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_graph_output(&mut self) -> *mut core::ffi::c_void; + fn get_molecule_output(&mut self) -> *mut core::ffi::c_void; + fn get_table_output(&mut self) -> *mut core::ffi::c_void; + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkPiecewiseFunctionAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkPiecewiseFunctionShiftScale { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_position_shift(&mut self, _arg: core::ffi::c_double) -> (); + fn set_position_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn set_value_shift(&mut self, _arg: core::ffi::c_double) -> (); + fn set_value_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn get_position_shift(&mut self) -> core::ffi::c_double; + fn get_position_scale(&mut self) -> core::ffi::c_double; + fn get_value_shift(&mut self) -> core::ffi::c_double; + fn get_value_scale(&mut self) -> core::ffi::c_double; +} +pub trait VtkPointSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPolyDataAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_poly_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkProgressObserver { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn update_progress(&mut self, amount: core::ffi::c_double) -> (); + fn get_progress(&mut self) -> core::ffi::c_double; +} +pub trait VtkReaderAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn create_output( + &mut self, + currentOutput: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn read_meta_data(&mut self, metadata: *mut core::ffi::c_void) -> core::ffi::c_int; + fn read_time_dependent_meta_data( + &mut self, + p0: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_mesh( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_points( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_arrays( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkReaderExecutive { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkRectilinearGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_rectilinear_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkSMPProgressObserver { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn update_progress(&mut self, progress: core::ffi::c_double) -> (); + fn get_local_observer(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkScalarTree { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn shallow_copy(&mut self, stree: *mut core::ffi::c_void) -> (); + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn set_scalars(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_scalars(&mut self) -> *mut core::ffi::c_void; + fn build_tree(&mut self) -> (); + fn initialize(&mut self) -> (); + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); + fn get_next_cell( + &mut self, + cellId: &mut core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_scalar_value(&mut self) -> core::ffi::c_double; + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_longlong; +} +pub trait VtkSelectionAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkSimpleImageToImageFilter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkSimpleReader { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_file_name(&mut self, fname: &str) -> (); + fn clear_file_names(&mut self) -> (); + fn get_number_of_file_names(&mut self) -> core::ffi::c_int; + fn get_file_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_current_file_name(&mut self) -> &str; + fn read_time_dependent_meta_data( + &mut self, + timestep: core::ffi::c_int, + metadata: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_meta_data(&mut self, metadata: *mut core::ffi::c_void) -> core::ffi::c_int; + fn read_mesh( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_points( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_arrays( + &mut self, + piece: core::ffi::c_int, + npieces: core::ffi::c_int, + nghosts: core::ffi::c_int, + timestep: core::ffi::c_int, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_time_value(&mut self, fname: &str) -> core::ffi::c_double; + fn read_meta_data_simple( + &mut self, + p0: &str, + p1: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_mesh_simple( + &mut self, + fname: &str, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_points_simple( + &mut self, + fname: &str, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn read_arrays_simple( + &mut self, + fname: &str, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; +} +pub trait VtkSimpleScalarTree { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_branching_factor(&mut self, _arg: core::ffi::c_int) -> (); + fn get_branching_factor_min_value(&mut self) -> core::ffi::c_int; + fn get_branching_factor_max_value(&mut self) -> core::ffi::c_int; + fn get_branching_factor(&mut self) -> core::ffi::c_int; + fn get_level(&mut self) -> core::ffi::c_int; + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_level_min_value(&mut self) -> core::ffi::c_int; + fn get_max_level_max_value(&mut self) -> core::ffi::c_int; + fn get_max_level(&mut self) -> core::ffi::c_int; + fn build_tree(&mut self) -> (); + fn initialize(&mut self) -> (); + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); + fn get_next_cell( + &mut self, + cellId: &mut core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_longlong; +} +pub trait VtkSpanSpace { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_scalar_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_compute_scalar_range(&mut self, _arg: core::ffi::c_int) -> (); + fn get_compute_scalar_range(&mut self) -> core::ffi::c_int; + fn compute_scalar_range_on(&mut self) -> (); + fn compute_scalar_range_off(&mut self) -> (); + fn set_resolution(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_longlong; + fn get_resolution_max_value(&mut self) -> core::ffi::c_longlong; + fn get_resolution(&mut self) -> core::ffi::c_longlong; + fn set_compute_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_compute_resolution(&mut self) -> core::ffi::c_int; + fn compute_resolution_on(&mut self) -> (); + fn compute_resolution_off(&mut self) -> (); + fn set_number_of_cells_per_bucket(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_cells_per_bucket_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_cells_per_bucket_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn build_tree(&mut self) -> (); + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> (); + fn get_next_cell( + &mut self, + cellId: &mut core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_longlong; + fn set_batch_size(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_batch_size_min_value(&mut self) -> core::ffi::c_longlong; + fn get_batch_size_max_value(&mut self) -> core::ffi::c_longlong; + fn get_batch_size(&mut self) -> core::ffi::c_longlong; +} +pub trait VtkSphereTree { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_data_set(&mut self) -> *mut core::ffi::c_void; + fn build(&mut self) -> (); + fn set_build_hierarchy(&mut self, _arg: bool) -> (); + fn get_build_hierarchy(&mut self) -> bool; + fn build_hierarchy_on(&mut self) -> (); + fn build_hierarchy_off(&mut self) -> (); + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_level_min_value(&mut self) -> core::ffi::c_int; + fn get_max_level_max_value(&mut self) -> core::ffi::c_int; + fn get_max_level(&mut self) -> core::ffi::c_int; + fn get_number_of_levels(&mut self) -> core::ffi::c_int; +} +pub trait VtkStreamingDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn update(&mut self) -> core::ffi::c_int; + fn update_whole_extent(&mut self) -> core::ffi::c_int; + fn propagate_update_extent( + &mut self, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + fn propagate_time(&mut self, outputPort: core::ffi::c_int) -> core::ffi::c_int; + fn update_time_dependent_information( + &mut self, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + fn set_request_exact_extent( + &mut self, + port: core::ffi::c_int, + flag: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_request_exact_extent(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn request_update_extent(&mut self) -> *mut core::ffi::c_void; + fn request_update_time(&mut self) -> *mut core::ffi::c_void; + fn request_time_dependent_information(&mut self) -> *mut core::ffi::c_void; + fn continue_executing(&mut self) -> *mut core::ffi::c_void; + fn update_extent_initialized(&mut self) -> *mut core::ffi::c_void; + fn update_extent(&mut self) -> *mut core::ffi::c_void; + fn update_piece_number(&mut self) -> *mut core::ffi::c_void; + fn update_number_of_pieces(&mut self) -> *mut core::ffi::c_void; + fn update_number_of_ghost_levels(&mut self) -> *mut core::ffi::c_void; + fn combined_update_extent(&mut self) -> *mut core::ffi::c_void; + fn whole_extent(&mut self) -> *mut core::ffi::c_void; + fn unrestricted_update_extent(&mut self) -> *mut core::ffi::c_void; + fn exact_extent(&mut self) -> *mut core::ffi::c_void; + fn time_steps(&mut self) -> *mut core::ffi::c_void; + fn time_range(&mut self) -> *mut core::ffi::c_void; + fn update_time_step(&mut self) -> *mut core::ffi::c_void; + fn time_dependent_information(&mut self) -> *mut core::ffi::c_void; + fn bounds(&mut self) -> *mut core::ffi::c_void; + fn get_update_piece(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_update_number_of_pieces( + &mut self, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + fn get_update_ghost_level(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int; +} +pub trait VtkStructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkTableAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkThreadedCompositeDataPipeline { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkThreadedImageAlgorithm { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_enable_smp(&mut self) -> bool; + fn set_enable_smp(&mut self, _arg: bool) -> (); + fn set_global_default_enable_smp(&mut self, enable: bool) -> (); + fn get_global_default_enable_smp(&mut self) -> bool; + fn set_minimum_piece_size( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + ) -> (); + fn set_desired_bytes_per_piece(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_desired_bytes_per_piece(&mut self) -> core::ffi::c_longlong; + fn set_split_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_split_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_split_mode_max_value(&mut self) -> core::ffi::c_int; + fn set_split_mode_to_slab(&mut self) -> (); + fn set_split_mode_to_beam(&mut self) -> (); + fn set_split_mode_to_block(&mut self) -> (); + fn get_split_mode(&mut self) -> core::ffi::c_int; + fn set_number_of_threads(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_threads_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_threads(&mut self) -> core::ffi::c_int; +} +pub trait VtkTreeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkTrivialConsumer { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkTrivialProducer { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, output: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> (); + fn fill_output_data_information( + &mut self, + output: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> (); +} +pub trait VtkUndirectedGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> (); +} +pub trait VtkUniformGridAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkUniformGridPartitioner { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_partitions(&mut self) -> core::ffi::c_int; + fn set_number_of_partitions(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int; + fn set_number_of_ghost_layers(&mut self, _arg: core::ffi::c_int) -> (); + fn get_duplicate_nodes(&mut self) -> core::ffi::c_int; + fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> (); + fn duplicate_nodes_on(&mut self) -> (); + fn duplicate_nodes_off(&mut self) -> (); +} +pub trait VtkUnstructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_unstructured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +pub trait VtkUnstructuredGridBaseAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_output(&mut self) -> *mut core::ffi::c_void; + fn set_output(&mut self, d: *mut core::ffi::c_void) -> (); + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> (); +} +impl VtkAlgorithm for vtkAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_new_instance(self.0) } + } + fn has_executive(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_has_executive( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_has_executive(self.0) } + } + fn get_executive(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_executive( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_executive(self.0) } + } + fn set_executive(&mut self, executive: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_executive( + sself: *mut core::ffi::c_void, + executive: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_executive(self.0, executive) } + } + fn process_request( + &mut self, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_process_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + inInfo: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_process_request(self.0, request, inInfo, outInfo) } + } + fn modify_request( + &mut self, + request: *mut core::ffi::c_void, + when: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_modify_request( + sself: *mut core::ffi::c_void, + request: *mut core::ffi::c_void, + when: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_modify_request(self.0, request, when) } + } + fn get_input_port_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_port_information( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_port_information(self.0, port) } + } + fn get_output_port_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_port_information( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_port_information(self.0, port) } + } + fn get_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_information(self.0) } + } + fn set_information(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_information( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_information(self.0, p0) } + } + fn get_number_of_input_ports(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_number_of_input_ports( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_number_of_input_ports(self.0) } + } + fn get_number_of_output_ports(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_number_of_output_ports( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_number_of_output_ports(self.0) } + } + fn register(&mut self, o: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_register( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_register(self.0, o) } + } + fn set_abort_execute(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_abort_execute( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_set_abort_execute(self.0, _arg) } + } + fn get_abort_execute(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_abort_execute( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_abort_execute(self.0) } + } + fn abort_execute_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_abort_execute_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_abort_execute_on(self.0) } + } + fn abort_execute_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_abort_execute_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_abort_execute_off(self.0) } + } + fn get_progress(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_algorithm_get_progress( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_algorithm_get_progress(self.0) } + } + fn set_progress(&mut self, p0: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_progress( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + ); + } + unsafe { vtk_algorithm_set_progress(self.0, p0) } + } + fn update_progress(&mut self, amount: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_algorithm_update_progress( + sself: *mut core::ffi::c_void, + amount: core::ffi::c_double, + ); + } + unsafe { vtk_algorithm_update_progress(self.0, amount) } + } + fn set_progress_shift_scale( + &mut self, + shift: core::ffi::c_double, + scale: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_progress_shift_scale( + sself: *mut core::ffi::c_void, + shift: core::ffi::c_double, + scale: core::ffi::c_double, + ); + } + unsafe { vtk_algorithm_set_progress_shift_scale(self.0, shift, scale) } + } + fn get_progress_shift(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_algorithm_get_progress_shift( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_algorithm_get_progress_shift(self.0) } + } + fn get_progress_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_algorithm_get_progress_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_algorithm_get_progress_scale(self.0) } + } + fn set_progress_text(&mut self, ptext: &str) -> () { + let c_ptext = std::ffi::CString::new(ptext).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_algorithm_set_progress_text( + sself: *mut core::ffi::c_void, + ptext: *const core::ffi::c_char, + ); + } + unsafe { vtk_algorithm_set_progress_text(self.0, c_ptext.as_ptr()) } + } + fn get_error_code(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_algorithm_get_error_code( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_algorithm_get_error_code(self.0) } + } + fn input_is_optional(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_is_optional( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_is_optional(self.0) } + } + fn input_is_repeatable(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_is_repeatable( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_is_repeatable(self.0) } + } + fn input_required_fields(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_required_fields( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_required_fields(self.0) } + } + fn input_required_data_type(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_required_data_type( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_required_data_type(self.0) } + } + fn input_arrays_to_process(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_arrays_to_process( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_arrays_to_process(self.0) } + } + fn input_port(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_port( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_port(self.0) } + } + fn input_connection(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_input_connection( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_input_connection(self.0) } + } + fn can_produce_sub_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_can_produce_sub_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_can_produce_sub_extent(self.0) } + } + fn can_handle_piece_request(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_can_handle_piece_request( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_can_handle_piece_request(self.0) } + } + fn set_input_array_to_process( + &mut self, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + name: &str, + ) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_algorithm_set_input_array_to_process( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + port: core::ffi::c_int, + connection: core::ffi::c_int, + fieldAssociation: core::ffi::c_int, + name: *const core::ffi::c_char, + ); + } + unsafe { + vtk_algorithm_set_input_array_to_process( + self.0, + idx, + port, + connection, + fieldAssociation, + c_name.as_ptr(), + ) + } + } + fn get_input_array_information( + &mut self, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_array_information( + sself: *mut core::ffi::c_void, + idx: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_array_information(self.0, idx) } + } + fn remove_all_inputs(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_remove_all_inputs(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_remove_all_inputs(self.0) } + } + fn get_output_data_object( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_data_object( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_data_object(self.0, port) } + } + fn get_input_data_object( + &mut self, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_data_object( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + connection: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_data_object(self.0, port, connection) } + } + fn set_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_input_connection(self.0, port, input) } + } + fn add_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_add_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_add_input_connection(self.0, port, input) } + } + fn remove_input_connection( + &mut self, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_remove_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_remove_input_connection(self.0, port, input) } + } + fn remove_all_input_connections(&mut self, port: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_remove_all_input_connections( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_remove_all_input_connections(self.0, port) } + } + fn set_input_data_object( + &mut self, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_input_data_object( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_input_data_object(self.0, port, data) } + } + fn add_input_data_object( + &mut self, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_add_input_data_object( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + data: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_add_input_data_object(self.0, port, data) } + } + fn get_output_port(&mut self, index: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_port( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_port(self.0, index) } + } + fn get_number_of_input_connections( + &mut self, + port: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_number_of_input_connections( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_number_of_input_connections(self.0, port) } + } + fn get_total_number_of_input_connections(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_total_number_of_input_connections( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_total_number_of_input_connections(self.0) } + } + fn get_input_connection( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_connection( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_connection(self.0, port, index) } + } + fn get_input_algorithm( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + algPort: &mut core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_algorithm( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + algPort: &mut core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_algorithm(self.0, port, index, algPort) } + } + fn get_input_executive( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_executive( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_executive(self.0, port, index) } + } + fn get_input_information( + &mut self, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_input_information( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + index: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_input_information(self.0, port, index) } + } + fn get_output_information( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_output_information( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_output_information(self.0, port) } + } + fn update(&mut self, port: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_update( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_update(self.0, port) } + } + fn update_information(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_update_information(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_update_information(self.0) } + } + fn update_data_object(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_update_data_object(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_update_data_object(self.0) } + } + fn propagate_update_extent(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_propagate_update_extent(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_propagate_update_extent(self.0) } + } + fn update_whole_extent(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_update_whole_extent(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_update_whole_extent(self.0) } + } + fn convert_total_input_to_port_connection( + &mut self, + ind: core::ffi::c_int, + port: &mut core::ffi::c_int, + conn: &mut core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_algorithm_convert_total_input_to_port_connection( + sself: *mut core::ffi::c_void, + ind: core::ffi::c_int, + port: &mut core::ffi::c_int, + conn: &mut core::ffi::c_int, + ); + } + unsafe { + vtk_algorithm_convert_total_input_to_port_connection(self.0, ind, port, conn) + } + } + fn set_release_data_flag(&mut self, p0: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_release_data_flag( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_set_release_data_flag(self.0, p0) } + } + fn get_release_data_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_release_data_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_release_data_flag(self.0) } + } + fn release_data_flag_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_release_data_flag_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_release_data_flag_on(self.0) } + } + fn release_data_flag_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_algorithm_release_data_flag_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_algorithm_release_data_flag_off(self.0) } + } + fn update_extent_is_empty( + &mut self, + pinfo: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_update_extent_is_empty( + sself: *mut core::ffi::c_void, + pinfo: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_update_extent_is_empty(self.0, pinfo, output) } + } + fn set_default_executive_prototype(&mut self, proto: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_default_executive_prototype( + sself: *mut core::ffi::c_void, + proto: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_default_executive_prototype(self.0, proto) } + } + fn get_update_piece(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_piece( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_piece(self.0) } + } + fn get_update_number_of_pieces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_number_of_pieces(self.0) } + } + fn get_update_ghost_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_get_update_ghost_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_get_update_ghost_level(self.0) } + } + fn set_progress_observer(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_set_progress_observer( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_set_progress_observer(self.0, p0) } + } + fn get_progress_observer(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_get_progress_observer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_get_progress_observer(self.0) } + } +} +impl VtkAlgorithmOutput for vtkAlgorithmOutput { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_output_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_output_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_output_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_output_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_output_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_output_new_instance(self.0) } + } + fn set_index(&mut self, index: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_algorithm_output_set_index( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ); + } + unsafe { vtk_algorithm_output_set_index(self.0, index) } + } + fn get_index(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_algorithm_output_get_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_algorithm_output_get_index(self.0) } + } + fn get_producer(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_algorithm_output_get_producer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_algorithm_output_get_producer(self.0) } + } + fn set_producer(&mut self, producer: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_algorithm_output_set_producer( + sself: *mut core::ffi::c_void, + producer: *mut core::ffi::c_void, + ); + } + unsafe { vtk_algorithm_output_set_producer(self.0, producer) } + } +} +impl VtkAnnotationLayersAlgorithm for vtkAnnotationLayersAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_annotation_layers_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_annotation_layers_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_annotation_layers_algorithm_set_input_data(self.0, obj) } + } +} +impl VtkArrayDataAlgorithm for vtkArrayDataAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_array_data_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_array_data_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_array_data_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_array_data_algorithm_set_input_data(self.0, obj) } + } +} +impl VtkCachedStreamingDemandDrivenPipeline for vtkCachedStreamingDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cached_streaming_demand_driven_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cached_streaming_demand_driven_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cached_streaming_demand_driven_pipeline_new_instance(self.0) } + } + fn set_cache_size(&mut self, size: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_set_cache_size( + sself: *mut core::ffi::c_void, + size: core::ffi::c_int, + ); + } + unsafe { + vtk_cached_streaming_demand_driven_pipeline_set_cache_size(self.0, size) + } + } + fn get_cache_size(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cached_streaming_demand_driven_pipeline_get_cache_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cached_streaming_demand_driven_pipeline_get_cache_size(self.0) } + } +} +impl VtkCastToConcrete for vtkCastToConcrete { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cast_to_concrete_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cast_to_concrete_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cast_to_concrete_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cast_to_concrete_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cast_to_concrete_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cast_to_concrete_new_instance(self.0) } + } +} +impl VtkCompositeDataPipeline for vtkCompositeDataPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_new_instance(self.0) } + } + fn get_composite_output_data( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_get_composite_output_data( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_get_composite_output_data(self.0, port) } + } + fn load_requested_blocks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_load_requested_blocks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_load_requested_blocks(self.0) } + } + fn composite_data_meta_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_composite_data_meta_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_composite_data_meta_data(self.0) } + } + fn update_composite_indices(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_update_composite_indices( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_update_composite_indices(self.0) } + } + fn block_amount_of_detail(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_pipeline_block_amount_of_detail( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_pipeline_block_amount_of_detail(self.0) } + } +} +impl VtkCompositeDataSetAlgorithm for vtkCompositeDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_composite_data_set_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_composite_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_composite_data_set_algorithm_set_input_data(self.0, p0) } + } +} +impl VtkDataObjectAlgorithm for vtkDataObjectAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_algorithm_set_output(self.0, d) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_object_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_object_algorithm_get_input(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_object_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_object_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkDataSetAlgorithm for vtkDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_output(self.0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_input(self.0) } + } + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_poly_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_poly_data_output(self.0) } + } + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_structured_points_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_structured_points_output(self.0) } + } + fn get_image_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_image_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_image_data_output(self.0) } + } + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_structured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_structured_grid_output(self.0) } + } + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_unstructured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_unstructured_grid_output(self.0) } + } + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_data_set_algorithm_get_rectilinear_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_data_set_algorithm_get_rectilinear_grid_output(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_data_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_data_set_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkDemandDrivenPipeline for vtkDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_new_instance(self.0) } + } + fn get_pipeline_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_get_pipeline_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_demand_driven_pipeline_get_pipeline_m_time(self.0) } + } + fn set_release_data_flag( + &mut self, + port: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_set_release_data_flag( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + n: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_set_release_data_flag(self.0, port, n) } + } + fn get_release_data_flag(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_get_release_data_flag( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_get_release_data_flag(self.0, port) } + } + fn update_pipeline_m_time(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_update_pipeline_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_update_pipeline_m_time(self.0) } + } + fn update_data_object(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_update_data_object( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_update_data_object(self.0) } + } + fn update_data(&mut self, outputPort: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_update_data( + sself: *mut core::ffi::c_void, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_demand_driven_pipeline_update_data(self.0, outputPort) } + } + fn request_data_object(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_request_data_object( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_request_data_object(self.0) } + } + fn request_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_request_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_request_information(self.0) } + } + fn request_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_request_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_request_data(self.0) } + } + fn request_data_not_generated(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_request_data_not_generated( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_request_data_not_generated(self.0) } + } + fn release_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_release_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_release_data(self.0) } + } + fn data_not_generated(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_demand_driven_pipeline_data_not_generated( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_data_not_generated(self.0) } + } + fn new_data_object(&mut self, type_: &str) -> *mut core::ffi::c_void { + let c_type = std::ffi::CString::new(type_).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_demand_driven_pipeline_new_data_object( + sself: *mut core::ffi::c_void, + type_: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_demand_driven_pipeline_new_data_object(self.0, c_type.as_ptr()) } + } +} +impl VtkDirectedGraphAlgorithm for vtkDirectedGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directed_graph_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_directed_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_directed_graph_algorithm_set_input_data(self.0, obj) } + } +} +impl VtkEnsembleSource for vtkEnsembleSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_new_instance(self.0) } + } + fn add_member(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_ensemble_source_add_member( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ensemble_source_add_member(self.0, p0) } + } + fn remove_all_members(&mut self) -> () { + unsafe extern "C" { + fn vtk_ensemble_source_remove_all_members(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ensemble_source_remove_all_members(self.0) } + } + fn get_number_of_members(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_ensemble_source_get_number_of_members( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_ensemble_source_get_number_of_members(self.0) } + } + fn set_current_member(&mut self, _arg: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_ensemble_source_set_current_member( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uint, + ); + } + unsafe { vtk_ensemble_source_set_current_member(self.0, _arg) } + } + fn get_current_member(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_ensemble_source_get_current_member( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_ensemble_source_get_current_member(self.0) } + } + fn set_meta_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_ensemble_source_set_meta_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_ensemble_source_set_meta_data(self.0, p0) } + } + fn meta_data(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_meta_data( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_meta_data(self.0) } + } + fn update_member(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ensemble_source_update_member( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ensemble_source_update_member(self.0) } + } +} +impl VtkExplicitStructuredGridAlgorithm for vtkExplicitStructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_algorithm_set_output(self.0, d) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_explicit_structured_grid_algorithm_get_input(self.0) } + } + fn get_explicit_structured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_get_explicit_structured_grid_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_explicit_structured_grid_algorithm_get_explicit_structured_grid_input( + self.0, + port, + ) + } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_explicit_structured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_explicit_structured_grid_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkExtentRCBPartitioner for vtkExtentRCBPartitioner { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_rcb_partitioner_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_rcb_partitioner_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_rcb_partitioner_new_instance(self.0) } + } + fn set_number_of_partitions(&mut self, N: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_number_of_partitions( + sself: *mut core::ffi::c_void, + N: core::ffi::c_int, + ); + } + unsafe { vtk_extent_rcb_partitioner_set_number_of_partitions(self.0, N) } + } + fn set_global_extent( + &mut self, + imin: core::ffi::c_int, + imax: core::ffi::c_int, + jmin: core::ffi::c_int, + jmax: core::ffi::c_int, + kmin: core::ffi::c_int, + kmax: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_global_extent( + sself: *mut core::ffi::c_void, + imin: core::ffi::c_int, + imax: core::ffi::c_int, + jmin: core::ffi::c_int, + jmax: core::ffi::c_int, + kmin: core::ffi::c_int, + kmax: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_rcb_partitioner_set_global_extent( + self.0, + imin, + imax, + jmin, + jmax, + kmin, + kmax, + ) + } + } + fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_duplicate_nodes( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_rcb_partitioner_set_duplicate_nodes(self.0, _arg) } + } + fn get_duplicate_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_get_duplicate_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_rcb_partitioner_get_duplicate_nodes(self.0) } + } + fn duplicate_nodes_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_duplicate_nodes_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_rcb_partitioner_duplicate_nodes_on(self.0) } + } + fn duplicate_nodes_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_duplicate_nodes_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_rcb_partitioner_duplicate_nodes_off(self.0) } + } + fn set_number_of_ghost_layers(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_set_number_of_ghost_layers( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_rcb_partitioner_set_number_of_ghost_layers(self.0, _arg) } + } + fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_get_number_of_ghost_layers( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_rcb_partitioner_get_number_of_ghost_layers(self.0) } + } + fn get_num_extents(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_get_num_extents( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_rcb_partitioner_get_num_extents(self.0) } + } + fn partition(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_rcb_partitioner_partition(sself: *mut core::ffi::c_void); + } + unsafe { vtk_extent_rcb_partitioner_partition(self.0) } + } +} +impl VtkExtentSplitter for vtkExtentSplitter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_splitter_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_splitter_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_splitter_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_splitter_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_splitter_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_splitter_new(self.0) } + } + fn add_extent_source( + &mut self, + id: core::ffi::c_int, + priority: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_add_extent_source( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + priority: core::ffi::c_int, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_splitter_add_extent_source( + self.0, + id, + priority, + x0, + x1, + y0, + y1, + z0, + z1, + ) + } + } + fn remove_extent_source(&mut self, id: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_remove_extent_source( + sself: *mut core::ffi::c_void, + id: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_remove_extent_source(self.0, id) } + } + fn remove_all_extent_sources(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_remove_all_extent_sources( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_splitter_remove_all_extent_sources(self.0) } + } + fn add_extent( + &mut self, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_add_extent( + sself: *mut core::ffi::c_void, + x0: core::ffi::c_int, + x1: core::ffi::c_int, + y0: core::ffi::c_int, + y1: core::ffi::c_int, + z0: core::ffi::c_int, + z1: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_add_extent(self.0, x0, x1, y0, y1, z0, z1) } + } + fn compute_sub_extents(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_compute_sub_extents( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_splitter_compute_sub_extents(self.0) } + } + fn get_number_of_sub_extents(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_get_number_of_sub_extents( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_splitter_get_number_of_sub_extents(self.0) } + } + fn get_sub_extent_source(&mut self, index: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_get_sub_extent_source( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_splitter_get_sub_extent_source(self.0, index) } + } + fn get_point_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_splitter_get_point_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_splitter_get_point_mode(self.0) } + } + fn set_point_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_set_point_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_splitter_set_point_mode(self.0, _arg) } + } + fn point_mode_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_point_mode_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_extent_splitter_point_mode_on(self.0) } + } + fn point_mode_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_splitter_point_mode_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_extent_splitter_point_mode_off(self.0) } + } +} +impl VtkExtentTranslator for vtkExtentTranslator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_translator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_translator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_translator_new_instance(self.0) } + } + fn set_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_whole_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_translator_set_whole_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_extent_translator_set_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_piece(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_piece( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_piece(self.0, _arg) } + } + fn get_piece(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_piece( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_piece(self.0) } + } + fn set_number_of_pieces(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_number_of_pieces( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_number_of_pieces(self.0, _arg) } + } + fn get_number_of_pieces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_number_of_pieces(self.0) } + } + fn set_ghost_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_ghost_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_extent_translator_set_ghost_level(self.0, _arg) } + } + fn get_ghost_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_ghost_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_ghost_level(self.0) } + } + fn piece_to_extent(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_piece_to_extent( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_piece_to_extent(self.0) } + } + fn piece_to_extent_by_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_piece_to_extent_by_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_piece_to_extent_by_points(self.0) } + } + fn set_split_mode_to_block(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_mode_to_block( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_translator_set_split_mode_to_block(self.0) } + } + fn set_split_mode_to_x_slab(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_mode_to_x_slab( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_translator_set_split_mode_to_x_slab(self.0) } + } + fn set_split_mode_to_y_slab(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_mode_to_y_slab( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_translator_set_split_mode_to_y_slab(self.0) } + } + fn set_split_mode_to_z_slab(&mut self) -> () { + unsafe extern "C" { + fn vtk_extent_translator_set_split_mode_to_z_slab( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_extent_translator_set_split_mode_to_z_slab(self.0) } + } + fn get_split_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_extent_translator_get_split_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_extent_translator_get_split_mode(self.0) } + } + fn update_split_mode(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_extent_translator_update_split_mode( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_extent_translator_update_split_mode(self.0) } + } +} +impl VtkGraphAlgorithm for vtkGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_graph_algorithm_set_input_data(self.0, obj) } + } +} +impl VtkHierarchicalBoxDataSetAlgorithm for vtkHierarchicalBoxDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hierarchical_box_data_set_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hierarchical_box_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hierarchical_box_data_set_algorithm_set_input_data(self.0, p0) } + } +} +impl VtkImageToStructuredGrid for vtkImageToStructuredGrid { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_grid_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_grid_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_grid_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_grid_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_grid_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_grid_new_instance(self.0) } + } +} +impl VtkImageToStructuredPoints for vtkImageToStructuredPoints { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_new_instance(self.0) } + } + fn set_vector_input_data(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_image_to_structured_points_set_vector_input_data( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_image_to_structured_points_set_vector_input_data(self.0, input) } + } + fn get_vector_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_get_vector_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_get_vector_input(self.0) } + } + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_image_to_structured_points_get_structured_points_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_image_to_structured_points_get_structured_points_output(self.0) } + } +} +impl VtkMoleculeAlgorithm for vtkMoleculeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_algorithm_set_output(self.0, d) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_get_input(self.0) } + } + fn get_molecule_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_molecule_algorithm_get_molecule_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_molecule_algorithm_get_molecule_input(self.0, port) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_molecule_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_molecule_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkMultiBlockDataSetAlgorithm for vtkMultiBlockDataSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_block_data_set_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_multi_block_data_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_multi_block_data_set_algorithm_set_input_data(self.0, p0) } + } +} +impl VtkMultiTimeStepAlgorithm for vtkMultiTimeStepAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_time_step_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_time_step_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_time_step_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_time_step_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_multi_time_step_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_multi_time_step_algorithm_new_instance(self.0) } + } +} +impl VtkNonOverlappingAMRAlgorithm for vtkNonOverlappingAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_non_overlapping_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_non_overlapping_amr_algorithm_get_output(self.0) } + } +} +impl VtkOverlappingAMRAlgorithm for vtkOverlappingAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_overlapping_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_overlapping_amr_algorithm_get_output(self.0) } + } +} +impl VtkPassInputTypeAlgorithm for vtkPassInputTypeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_output(self.0) } + } + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_poly_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_poly_data_output(self.0) } + } + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_structured_points_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_structured_points_output(self.0) } + } + fn get_image_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_image_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_image_data_output(self.0) } + } + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_structured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_structured_grid_output(self.0) } + } + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_unstructured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_unstructured_grid_output(self.0) } + } + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_rectilinear_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_rectilinear_grid_output(self.0) } + } + fn get_graph_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_graph_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_graph_output(self.0) } + } + fn get_molecule_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_molecule_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_molecule_output(self.0) } + } + fn get_table_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_table_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_table_output(self.0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_pass_input_type_algorithm_get_input(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_pass_input_type_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_pass_input_type_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_pass_input_type_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkPiecewiseFunctionAlgorithm for vtkPiecewiseFunctionAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_algorithm_set_output(self.0, d) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_algorithm_get_input(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_piecewise_function_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkPiecewiseFunctionShiftScale for vtkPiecewiseFunctionShiftScale { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_shift_scale_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_shift_scale_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_piecewise_function_shift_scale_new_instance(self.0) } + } + fn set_position_shift(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_set_position_shift( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_shift_scale_set_position_shift(self.0, _arg) } + } + fn set_position_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_set_position_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_shift_scale_set_position_scale(self.0, _arg) } + } + fn set_value_shift(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_set_value_shift( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_shift_scale_set_value_shift(self.0, _arg) } + } + fn set_value_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_set_value_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_piecewise_function_shift_scale_set_value_scale(self.0, _arg) } + } + fn get_position_shift(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_get_position_shift( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_shift_scale_get_position_shift(self.0) } + } + fn get_position_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_get_position_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_shift_scale_get_position_scale(self.0) } + } + fn get_value_shift(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_get_value_shift( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_shift_scale_get_value_shift(self.0) } + } + fn get_value_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_piecewise_function_shift_scale_get_value_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_piecewise_function_shift_scale_get_value_scale(self.0) } + } +} +impl VtkPointSetAlgorithm for vtkPointSetAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_output(self.0) } + } + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_poly_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_poly_data_output(self.0) } + } + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_structured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_structured_grid_output(self.0) } + } + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_unstructured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_unstructured_grid_output(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_set_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_set_algorithm_add_input_data(self.0, p0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_set_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_set_algorithm_get_input(self.0) } + } +} +impl VtkPolyDataAlgorithm for vtkPolyDataAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_algorithm_set_output(self.0, d) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_get_input(self.0) } + } + fn get_poly_data_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_data_algorithm_get_poly_data_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_data_algorithm_get_poly_data_input(self.0, port) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_data_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_data_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkProgressObserver for vtkProgressObserver { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_progress_observer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_progress_observer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_progress_observer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_progress_observer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_progress_observer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_progress_observer_new_instance(self.0) } + } + fn update_progress(&mut self, amount: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_progress_observer_update_progress( + sself: *mut core::ffi::c_void, + amount: core::ffi::c_double, + ); + } + unsafe { vtk_progress_observer_update_progress(self.0, amount) } + } + fn get_progress(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_progress_observer_get_progress( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_progress_observer_get_progress(self.0) } + } +} +impl VtkReaderExecutive for vtkReaderExecutive { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reader_executive_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reader_executive_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reader_executive_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reader_executive_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_reader_executive_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_reader_executive_new_instance(self.0) } + } +} +impl VtkRectilinearGridAlgorithm for vtkRectilinearGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_algorithm_set_output(self.0, d) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectilinear_grid_algorithm_get_input(self.0) } + } + fn get_rectilinear_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_get_rectilinear_grid_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_rectilinear_grid_algorithm_get_rectilinear_grid_input(self.0, port) + } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_rectilinear_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_rectilinear_grid_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkSMPProgressObserver for vtkSMPProgressObserver { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smp_progress_observer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smp_progress_observer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smp_progress_observer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smp_progress_observer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smp_progress_observer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smp_progress_observer_new_instance(self.0) } + } + fn update_progress(&mut self, progress: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_smp_progress_observer_update_progress( + sself: *mut core::ffi::c_void, + progress: core::ffi::c_double, + ); + } + unsafe { vtk_smp_progress_observer_update_progress(self.0, progress) } + } + fn get_local_observer(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_smp_progress_observer_get_local_observer( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_smp_progress_observer_get_local_observer(self.0) } + } +} +impl VtkSelectionAlgorithm for vtkSelectionAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_selection_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_algorithm_set_input_data(self.0, obj) } + } +} +impl VtkSimpleScalarTree for vtkSimpleScalarTree { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_scalar_tree_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_scalar_tree_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_scalar_tree_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_scalar_tree_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_scalar_tree_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_simple_scalar_tree_new_instance(self.0) } + } + fn set_branching_factor(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_set_branching_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_simple_scalar_tree_set_branching_factor(self.0, _arg) } + } + fn get_branching_factor_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_branching_factor_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_branching_factor_min_value(self.0) } + } + fn get_branching_factor_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_branching_factor_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_branching_factor_max_value(self.0) } + } + fn get_branching_factor(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_branching_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_branching_factor(self.0) } + } + fn get_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_level(self.0) } + } + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_set_max_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_simple_scalar_tree_set_max_level(self.0, _arg) } + } + fn get_max_level_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_max_level_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_max_level_min_value(self.0) } + } + fn get_max_level_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_max_level_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_max_level_max_value(self.0) } + } + fn get_max_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_max_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_simple_scalar_tree_get_max_level(self.0) } + } + fn build_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_build_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_simple_scalar_tree_build_tree(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_simple_scalar_tree_initialize(self.0) } + } + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_simple_scalar_tree_init_traversal( + sself: *mut core::ffi::c_void, + scalarValue: core::ffi::c_double, + ); + } + unsafe { vtk_simple_scalar_tree_init_traversal(self.0, scalarValue) } + } + fn get_next_cell( + &mut self, + cellId: &mut core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_next_cell( + sself: *mut core::ffi::c_void, + cellId: &mut core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_simple_scalar_tree_get_next_cell(self.0, cellId, ptIds, cellScalars) + } + } + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_simple_scalar_tree_get_number_of_cell_batches( + sself: *mut core::ffi::c_void, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_simple_scalar_tree_get_number_of_cell_batches(self.0, scalarValue) } + } +} +impl VtkSpanSpace for vtkSpanSpace { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_span_space_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_span_space_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_span_space_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_span_space_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_span_space_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_span_space_new_instance(self.0) } + } + fn set_scalar_range( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_span_space_set_scalar_range( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ); + } + unsafe { vtk_span_space_set_scalar_range(self.0, _arg1, _arg2) } + } + fn set_compute_scalar_range(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_span_space_set_compute_scalar_range( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_span_space_set_compute_scalar_range(self.0, _arg) } + } + fn get_compute_scalar_range(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_compute_scalar_range( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_compute_scalar_range(self.0) } + } + fn compute_scalar_range_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_compute_scalar_range_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_compute_scalar_range_on(self.0) } + } + fn compute_scalar_range_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_compute_scalar_range_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_compute_scalar_range_off(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_span_space_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_span_space_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_span_space_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_span_space_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_span_space_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_span_space_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_span_space_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_span_space_get_resolution(self.0) } + } + fn set_compute_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_span_space_set_compute_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_span_space_set_compute_resolution(self.0, _arg) } + } + fn get_compute_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_compute_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_compute_resolution(self.0) } + } + fn compute_resolution_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_compute_resolution_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_compute_resolution_on(self.0) } + } + fn compute_resolution_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_compute_resolution_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_compute_resolution_off(self.0) } + } + fn set_number_of_cells_per_bucket(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_span_space_set_number_of_cells_per_bucket( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_span_space_set_number_of_cells_per_bucket(self.0, _arg) } + } + fn get_number_of_cells_per_bucket_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_number_of_cells_per_bucket_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_number_of_cells_per_bucket_min_value(self.0) } + } + fn get_number_of_cells_per_bucket_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_number_of_cells_per_bucket_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_number_of_cells_per_bucket_max_value(self.0) } + } + fn get_number_of_cells_per_bucket(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_span_space_get_number_of_cells_per_bucket( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_span_space_get_number_of_cells_per_bucket(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_initialize(self.0) } + } + fn build_tree(&mut self) -> () { + unsafe extern "C" { + fn vtk_span_space_build_tree(sself: *mut core::ffi::c_void); + } + unsafe { vtk_span_space_build_tree(self.0) } + } + fn init_traversal(&mut self, scalarValue: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_span_space_init_traversal( + sself: *mut core::ffi::c_void, + scalarValue: core::ffi::c_double, + ); + } + unsafe { vtk_span_space_init_traversal(self.0, scalarValue) } + } + fn get_next_cell( + &mut self, + cellId: &mut core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_span_space_get_next_cell( + sself: *mut core::ffi::c_void, + cellId: &mut core::ffi::c_longlong, + ptIds: *mut core::ffi::c_void, + cellScalars: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_span_space_get_next_cell(self.0, cellId, ptIds, cellScalars) } + } + fn get_number_of_cell_batches( + &mut self, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_span_space_get_number_of_cell_batches( + sself: *mut core::ffi::c_void, + scalarValue: core::ffi::c_double, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_span_space_get_number_of_cell_batches(self.0, scalarValue) } + } + fn set_batch_size(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_span_space_set_batch_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_span_space_set_batch_size(self.0, _arg) } + } + fn get_batch_size_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_span_space_get_batch_size_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_span_space_get_batch_size_min_value(self.0) } + } + fn get_batch_size_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_span_space_get_batch_size_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_span_space_get_batch_size_max_value(self.0) } + } + fn get_batch_size(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_span_space_get_batch_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_span_space_get_batch_size(self.0) } + } +} +impl VtkSphereTree for vtkSphereTree { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_tree_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_tree_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_tree_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_tree_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_tree_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_tree_new_instance(self.0) } + } + fn set_data_set(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_set_data_set( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sphere_tree_set_data_set(self.0, p0) } + } + fn get_data_set(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_tree_get_data_set( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_tree_get_data_set(self.0) } + } + fn build(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_build(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_tree_build(self.0) } + } + fn set_build_hierarchy(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_set_build_hierarchy( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_sphere_tree_set_build_hierarchy(self.0, _arg) } + } + fn get_build_hierarchy(&mut self) -> bool { + unsafe extern "C" { + fn vtk_sphere_tree_get_build_hierarchy( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_sphere_tree_get_build_hierarchy(self.0) } + } + fn build_hierarchy_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_build_hierarchy_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_tree_build_hierarchy_on(self.0) } + } + fn build_hierarchy_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_build_hierarchy_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_tree_build_hierarchy_off(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_tree_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_resolution(self.0) } + } + fn set_max_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_tree_set_max_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_tree_set_max_level(self.0, _arg) } + } + fn get_max_level_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_max_level_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_max_level_min_value(self.0) } + } + fn get_max_level_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_max_level_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_max_level_max_value(self.0) } + } + fn get_max_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_max_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_max_level(self.0) } + } + fn get_number_of_levels(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_tree_get_number_of_levels( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_tree_get_number_of_levels(self.0) } + } +} +impl VtkStreamingDemandDrivenPipeline for vtkStreamingDemandDrivenPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_new_instance(self.0) } + } + fn update(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_update(self.0) } + } + fn update_whole_extent(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_whole_extent( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_whole_extent(self.0) } + } + fn propagate_update_extent( + &mut self, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_propagate_update_extent( + sself: *mut core::ffi::c_void, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_propagate_update_extent( + self.0, + outputPort, + ) + } + } + fn propagate_time(&mut self, outputPort: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_propagate_time( + sself: *mut core::ffi::c_void, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_propagate_time(self.0, outputPort) + } + } + fn update_time_dependent_information( + &mut self, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_time_dependent_information( + sself: *mut core::ffi::c_void, + outputPort: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_update_time_dependent_information( + self.0, + outputPort, + ) + } + } + fn set_request_exact_extent( + &mut self, + port: core::ffi::c_int, + flag: core::ffi::c_int, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_set_request_exact_extent( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + flag: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_set_request_exact_extent( + self.0, + port, + flag, + ) + } + } + fn get_request_exact_extent(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_request_exact_extent( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_get_request_exact_extent(self.0, port) + } + } + fn request_update_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_request_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_request_update_extent(self.0) } + } + fn request_update_time(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_request_update_time( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_request_update_time(self.0) } + } + fn request_time_dependent_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_request_time_dependent_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_streaming_demand_driven_pipeline_request_time_dependent_information( + self.0, + ) + } + } + fn continue_executing(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_continue_executing( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_continue_executing(self.0) } + } + fn update_extent_initialized(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_extent_initialized( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_extent_initialized(self.0) } + } + fn update_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_extent(self.0) } + } + fn update_piece_number(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_piece_number( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_piece_number(self.0) } + } + fn update_number_of_pieces(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_number_of_pieces( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_number_of_pieces(self.0) } + } + fn update_number_of_ghost_levels(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_number_of_ghost_levels( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_streaming_demand_driven_pipeline_update_number_of_ghost_levels(self.0) + } + } + fn combined_update_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_combined_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_combined_update_extent(self.0) } + } + fn whole_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_whole_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_whole_extent(self.0) } + } + fn unrestricted_update_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_unrestricted_update_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_streaming_demand_driven_pipeline_unrestricted_update_extent(self.0) + } + } + fn exact_extent(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_exact_extent( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_exact_extent(self.0) } + } + fn time_steps(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_time_steps( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_time_steps(self.0) } + } + fn time_range(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_time_range( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_time_range(self.0) } + } + fn update_time_step(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_update_time_step( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_update_time_step(self.0) } + } + fn time_dependent_information(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_time_dependent_information( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_streaming_demand_driven_pipeline_time_dependent_information(self.0) + } + } + fn bounds(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_bounds( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_streaming_demand_driven_pipeline_bounds(self.0) } + } + fn get_update_piece(&mut self, p0: *mut core::ffi::c_void) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_update_piece( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_streaming_demand_driven_pipeline_get_update_piece(self.0, p0) } + } + fn get_update_number_of_pieces( + &mut self, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_update_number_of_pieces( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_get_update_number_of_pieces(self.0, p0) + } + } + fn get_update_ghost_level( + &mut self, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_streaming_demand_driven_pipeline_get_update_ghost_level( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_streaming_demand_driven_pipeline_get_update_ghost_level(self.0, p0) + } + } +} +impl VtkStructuredGridAlgorithm for vtkStructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_algorithm_set_output(self.0, d) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_get_input(self.0) } + } + fn get_structured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_get_structured_grid_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_structured_grid_algorithm_get_structured_grid_input(self.0, port) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_structured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_structured_grid_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkTableAlgorithm for vtkTableAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_table_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_table_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_table_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_table_algorithm_set_input_data(self.0, obj) } + } +} +impl VtkThreadedCompositeDataPipeline for vtkThreadedCompositeDataPipeline { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_threaded_composite_data_pipeline_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_threaded_composite_data_pipeline_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_threaded_composite_data_pipeline_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_threaded_composite_data_pipeline_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_threaded_composite_data_pipeline_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_threaded_composite_data_pipeline_new_instance(self.0) } + } +} +impl VtkTreeAlgorithm for vtkTreeAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tree_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tree_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_tree_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tree_algorithm_set_input_data(self.0, obj) } + } +} +impl VtkTrivialConsumer for vtkTrivialConsumer { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_consumer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_consumer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_consumer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_consumer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_consumer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_consumer_new_instance(self.0) } + } +} +impl VtkTrivialProducer for vtkTrivialProducer { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_producer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_producer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_producer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_producer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_trivial_producer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_trivial_producer_new_instance(self.0) } + } + fn set_output(&mut self, output: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_set_output( + sself: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + ); + } + unsafe { vtk_trivial_producer_set_output(self.0, output) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_trivial_producer_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_trivial_producer_get_m_time(self.0) } + } + fn set_whole_extent( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_set_whole_extent( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + _arg3: core::ffi::c_int, + _arg4: core::ffi::c_int, + _arg5: core::ffi::c_int, + _arg6: core::ffi::c_int, + ); + } + unsafe { + vtk_trivial_producer_set_whole_extent( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn fill_output_data_information( + &mut self, + output: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_trivial_producer_fill_output_data_information( + sself: *mut core::ffi::c_void, + output: *mut core::ffi::c_void, + outInfo: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_trivial_producer_fill_output_data_information(self.0, output, outInfo) + } + } +} +impl VtkUndirectedGraphAlgorithm for vtkUndirectedGraphAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_undirected_graph_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, obj: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_undirected_graph_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + obj: *mut core::ffi::c_void, + ); + } + unsafe { vtk_undirected_graph_algorithm_set_input_data(self.0, obj) } + } +} +impl VtkUniformGridAMRAlgorithm for vtkUniformGridAMRAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_amr_algorithm_get_output(self.0) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_amr_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_amr_algorithm_set_input_data(self.0, p0) } + } +} +impl VtkUniformGridPartitioner for vtkUniformGridPartitioner { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_partitioner_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_partitioner_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_grid_partitioner_new_instance(self.0) } + } + fn get_number_of_partitions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_get_number_of_partitions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_partitioner_get_number_of_partitions(self.0) } + } + fn set_number_of_partitions(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_set_number_of_partitions( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_partitioner_set_number_of_partitions(self.0, _arg) } + } + fn get_number_of_ghost_layers(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_get_number_of_ghost_layers( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_partitioner_get_number_of_ghost_layers(self.0) } + } + fn set_number_of_ghost_layers(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_set_number_of_ghost_layers( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_partitioner_set_number_of_ghost_layers(self.0, _arg) } + } + fn get_duplicate_nodes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_get_duplicate_nodes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_uniform_grid_partitioner_get_duplicate_nodes(self.0) } + } + fn set_duplicate_nodes(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_set_duplicate_nodes( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_uniform_grid_partitioner_set_duplicate_nodes(self.0, _arg) } + } + fn duplicate_nodes_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_duplicate_nodes_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_partitioner_duplicate_nodes_on(self.0) } + } + fn duplicate_nodes_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_uniform_grid_partitioner_duplicate_nodes_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_uniform_grid_partitioner_duplicate_nodes_off(self.0) } + } +} +impl VtkUnstructuredGridAlgorithm for vtkUnstructuredGridAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_algorithm_set_output(self.0, d) } + } + fn get_input(&mut self, port: core::ffi::c_int) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_get_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_algorithm_get_input(self.0, port) } + } + fn get_unstructured_grid_input( + &mut self, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_get_unstructured_grid_input( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_unstructured_grid_algorithm_get_unstructured_grid_input(self.0, port) + } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_algorithm_add_input_data(self.0, p0) } + } +} +impl VtkUnstructuredGridBaseAlgorithm for vtkUnstructuredGridBaseAlgorithm { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_new_instance(self.0) } + } + fn get_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_get_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_unstructured_grid_base_algorithm_get_output(self.0) } + } + fn set_output(&mut self, d: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_set_output( + sself: *mut core::ffi::c_void, + d: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_base_algorithm_set_output(self.0, d) } + } + fn set_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_set_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_base_algorithm_set_input_data(self.0, p0) } + } + fn add_input_data(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_unstructured_grid_base_algorithm_add_input_data( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_unstructured_grid_base_algorithm_add_input_data(self.0, p0) } + } +} /// Superclass for all sources, filters, and sinks in VTK. /// /// @@ -15,22 +5873,13 @@ #[allow(non_camel_case_types)] pub struct vtkAlgorithm(*mut core::ffi::c_void); impl vtkAlgorithm { - /// Creates a new [vtkAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkAlgorithm] via `vtkAlgorithm::New()` #[doc(alias = "vtkAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkAlgorithm_new() }) } } impl std::default::Default for vtkAlgorithm { @@ -50,12 +5899,8 @@ impl Drop for vtkAlgorithm { #[test] fn test_vtkAlgorithm_create_drop() { let obj = vtkAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Proxy object to connect input/output ports. /// @@ -70,22 +5915,13 @@ fn test_vtkAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAlgorithmOutput(*mut core::ffi::c_void); impl vtkAlgorithmOutput { - /// Creates a new [vtkAlgorithmOutput] wrapped inside `vtkNew` + /// Creates a new [vtkAlgorithmOutput] via `vtkAlgorithmOutput::New()` #[doc(alias = "vtkAlgorithmOutput")] pub fn new() -> Self { unsafe extern "C" { fn vtkAlgorithmOutput_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAlgorithmOutput_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAlgorithmOutput_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAlgorithmOutput_get_ptr(self.0) } + Self(unsafe { vtkAlgorithmOutput_new() }) } } impl std::default::Default for vtkAlgorithmOutput { @@ -105,12 +5941,8 @@ impl Drop for vtkAlgorithmOutput { #[test] fn test_vtkAlgorithmOutput_create_drop() { let obj = vtkAlgorithmOutput::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAlgorithmOutput(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only vtkAnnotationLayers as output /// @@ -130,22 +5962,13 @@ fn test_vtkAlgorithmOutput_create_drop() { #[allow(non_camel_case_types)] pub struct vtkAnnotationLayersAlgorithm(*mut core::ffi::c_void); impl vtkAnnotationLayersAlgorithm { - /// Creates a new [vtkAnnotationLayersAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkAnnotationLayersAlgorithm] via `vtkAnnotationLayersAlgorithm::New()` #[doc(alias = "vtkAnnotationLayersAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkAnnotationLayersAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAnnotationLayersAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAnnotationLayersAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAnnotationLayersAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkAnnotationLayersAlgorithm_new() }) } } impl std::default::Default for vtkAnnotationLayersAlgorithm { @@ -165,12 +5988,8 @@ impl Drop for vtkAnnotationLayersAlgorithm { #[test] fn test_vtkAnnotationLayersAlgorithm_create_drop() { let obj = vtkAnnotationLayersAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAnnotationLayersAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce /// @@ -192,22 +6011,13 @@ fn test_vtkAnnotationLayersAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkArrayDataAlgorithm(*mut core::ffi::c_void); impl vtkArrayDataAlgorithm { - /// Creates a new [vtkArrayDataAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkArrayDataAlgorithm] via `vtkArrayDataAlgorithm::New()` #[doc(alias = "vtkArrayDataAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkArrayDataAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkArrayDataAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkArrayDataAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkArrayDataAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkArrayDataAlgorithm_new() }) } } impl std::default::Default for vtkArrayDataAlgorithm { @@ -227,34 +6037,21 @@ impl Drop for vtkArrayDataAlgorithm { #[test] fn test_vtkArrayDataAlgorithm_create_drop() { let obj = vtkArrayDataAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkArrayDataAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// vtkCachedStreamingDemandDrivenPipeline #[allow(non_camel_case_types)] pub struct vtkCachedStreamingDemandDrivenPipeline(*mut core::ffi::c_void); impl vtkCachedStreamingDemandDrivenPipeline { - /// Creates a new [vtkCachedStreamingDemandDrivenPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkCachedStreamingDemandDrivenPipeline] via `vtkCachedStreamingDemandDrivenPipeline::New()` #[doc(alias = "vtkCachedStreamingDemandDrivenPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkCachedStreamingDemandDrivenPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCachedStreamingDemandDrivenPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCachedStreamingDemandDrivenPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCachedStreamingDemandDrivenPipeline_get_ptr(self.0) } + Self(unsafe { vtkCachedStreamingDemandDrivenPipeline_new() }) } } impl std::default::Default for vtkCachedStreamingDemandDrivenPipeline { @@ -276,12 +6073,8 @@ impl Drop for vtkCachedStreamingDemandDrivenPipeline { #[test] fn test_vtkCachedStreamingDemandDrivenPipeline_create_drop() { let obj = vtkCachedStreamingDemandDrivenPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCachedStreamingDemandDrivenPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// works around type-checking limitations /// @@ -309,22 +6102,13 @@ fn test_vtkCachedStreamingDemandDrivenPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCastToConcrete(*mut core::ffi::c_void); impl vtkCastToConcrete { - /// Creates a new [vtkCastToConcrete] wrapped inside `vtkNew` + /// Creates a new [vtkCastToConcrete] via `vtkCastToConcrete::New()` #[doc(alias = "vtkCastToConcrete")] pub fn new() -> Self { unsafe extern "C" { fn vtkCastToConcrete_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCastToConcrete_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCastToConcrete_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCastToConcrete_get_ptr(self.0) } + Self(unsafe { vtkCastToConcrete_new() }) } } impl std::default::Default for vtkCastToConcrete { @@ -344,12 +6128,8 @@ impl Drop for vtkCastToConcrete { #[test] fn test_vtkCastToConcrete_create_drop() { let obj = vtkCastToConcrete::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCastToConcrete(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive supporting composite datasets. /// @@ -364,7 +6144,7 @@ fn test_vtkCastToConcrete_create_drop() { /// * REQUEST_INFORMATION: The producers have to provide information about /// the contents of the composite dataset in this pass. /// Sources that can produce more than one piece (note that a piece is -/// different than a block; each piece consists of 0 or more blocks) should +/// different than a block; each piece consistes of 0 or more blocks) should /// set CAN_HANDLE_PIECE_REQUEST. /// /// * REQUEST_UPDATE_EXTENT: This pass is identical to the one implemented @@ -380,22 +6160,13 @@ fn test_vtkCastToConcrete_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCompositeDataPipeline(*mut core::ffi::c_void); impl vtkCompositeDataPipeline { - /// Creates a new [vtkCompositeDataPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkCompositeDataPipeline] via `vtkCompositeDataPipeline::New()` #[doc(alias = "vtkCompositeDataPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkCompositeDataPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCompositeDataPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCompositeDataPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCompositeDataPipeline_get_ptr(self.0) } + Self(unsafe { vtkCompositeDataPipeline_new() }) } } impl std::default::Default for vtkCompositeDataPipeline { @@ -415,12 +6186,8 @@ impl Drop for vtkCompositeDataPipeline { #[test] fn test_vtkCompositeDataPipeline_create_drop() { let obj = vtkCompositeDataPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCompositeDataPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only vtkCompositeDataSet as output /// @@ -431,22 +6198,13 @@ fn test_vtkCompositeDataPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkCompositeDataSetAlgorithm(*mut core::ffi::c_void); impl vtkCompositeDataSetAlgorithm { - /// Creates a new [vtkCompositeDataSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkCompositeDataSetAlgorithm] via `vtkCompositeDataSetAlgorithm::New()` #[doc(alias = "vtkCompositeDataSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkCompositeDataSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCompositeDataSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCompositeDataSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCompositeDataSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkCompositeDataSetAlgorithm_new() }) } } impl std::default::Default for vtkCompositeDataSetAlgorithm { @@ -466,12 +6224,8 @@ impl Drop for vtkCompositeDataSetAlgorithm { #[test] fn test_vtkCompositeDataSetAlgorithm_create_drop() { let obj = vtkCompositeDataSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCompositeDataSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only data object as output /// @@ -491,22 +6245,13 @@ fn test_vtkCompositeDataSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataObjectAlgorithm(*mut core::ffi::c_void); impl vtkDataObjectAlgorithm { - /// Creates a new [vtkDataObjectAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkDataObjectAlgorithm] via `vtkDataObjectAlgorithm::New()` #[doc(alias = "vtkDataObjectAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataObjectAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataObjectAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataObjectAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataObjectAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkDataObjectAlgorithm_new() }) } } impl std::default::Default for vtkDataObjectAlgorithm { @@ -526,12 +6271,8 @@ impl Drop for vtkDataObjectAlgorithm { #[test] fn test_vtkDataObjectAlgorithm_create_drop() { let obj = vtkDataObjectAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataObjectAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce output of the same type as input /// @@ -552,22 +6293,13 @@ fn test_vtkDataObjectAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDataSetAlgorithm(*mut core::ffi::c_void); impl vtkDataSetAlgorithm { - /// Creates a new [vtkDataSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkDataSetAlgorithm] via `vtkDataSetAlgorithm::New()` #[doc(alias = "vtkDataSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkDataSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDataSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDataSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDataSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkDataSetAlgorithm_new() }) } } impl std::default::Default for vtkDataSetAlgorithm { @@ -587,12 +6319,8 @@ impl Drop for vtkDataSetAlgorithm { #[test] fn test_vtkDataSetAlgorithm_create_drop() { let obj = vtkDataSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDataSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive supporting on-demand execution. /// @@ -603,22 +6331,13 @@ fn test_vtkDataSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDemandDrivenPipeline(*mut core::ffi::c_void); impl vtkDemandDrivenPipeline { - /// Creates a new [vtkDemandDrivenPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkDemandDrivenPipeline] via `vtkDemandDrivenPipeline::New()` #[doc(alias = "vtkDemandDrivenPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkDemandDrivenPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDemandDrivenPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDemandDrivenPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDemandDrivenPipeline_get_ptr(self.0) } + Self(unsafe { vtkDemandDrivenPipeline_new() }) } } impl std::default::Default for vtkDemandDrivenPipeline { @@ -638,12 +6357,8 @@ impl Drop for vtkDemandDrivenPipeline { #[test] fn test_vtkDemandDrivenPipeline_create_drop() { let obj = vtkDemandDrivenPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDemandDrivenPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only directed graph as output /// @@ -668,22 +6383,13 @@ fn test_vtkDemandDrivenPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDirectedGraphAlgorithm(*mut core::ffi::c_void); impl vtkDirectedGraphAlgorithm { - /// Creates a new [vtkDirectedGraphAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkDirectedGraphAlgorithm] via `vtkDirectedGraphAlgorithm::New()` #[doc(alias = "vtkDirectedGraphAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkDirectedGraphAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDirectedGraphAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDirectedGraphAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDirectedGraphAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkDirectedGraphAlgorithm_new() }) } } impl std::default::Default for vtkDirectedGraphAlgorithm { @@ -703,12 +6409,8 @@ impl Drop for vtkDirectedGraphAlgorithm { #[test] fn test_vtkDirectedGraphAlgorithm_create_drop() { let obj = vtkDirectedGraphAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDirectedGraphAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// source that manages dataset ensembles /// @@ -722,22 +6424,13 @@ fn test_vtkDirectedGraphAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkEnsembleSource(*mut core::ffi::c_void); impl vtkEnsembleSource { - /// Creates a new [vtkEnsembleSource] wrapped inside `vtkNew` + /// Creates a new [vtkEnsembleSource] via `vtkEnsembleSource::New()` #[doc(alias = "vtkEnsembleSource")] pub fn new() -> Self { unsafe extern "C" { fn vtkEnsembleSource_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkEnsembleSource_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkEnsembleSource_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkEnsembleSource_get_ptr(self.0) } + Self(unsafe { vtkEnsembleSource_new() }) } } impl std::default::Default for vtkEnsembleSource { @@ -757,12 +6450,8 @@ impl Drop for vtkEnsembleSource { #[test] fn test_vtkEnsembleSource_create_drop() { let obj = vtkEnsembleSource::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkEnsembleSource(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only /// @@ -770,22 +6459,13 @@ fn test_vtkEnsembleSource_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExplicitStructuredGridAlgorithm(*mut core::ffi::c_void); impl vtkExplicitStructuredGridAlgorithm { - /// Creates a new [vtkExplicitStructuredGridAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkExplicitStructuredGridAlgorithm] via `vtkExplicitStructuredGridAlgorithm::New()` #[doc(alias = "vtkExplicitStructuredGridAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkExplicitStructuredGridAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExplicitStructuredGridAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExplicitStructuredGridAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExplicitStructuredGridAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkExplicitStructuredGridAlgorithm_new() }) } } impl std::default::Default for vtkExplicitStructuredGridAlgorithm { @@ -807,12 +6487,8 @@ impl Drop for vtkExplicitStructuredGridAlgorithm { #[test] fn test_vtkExplicitStructuredGridAlgorithm_create_drop() { let obj = vtkExplicitStructuredGridAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExplicitStructuredGridAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// This method partitions a global extent to N partitions where N is a user /// @@ -820,22 +6496,13 @@ fn test_vtkExplicitStructuredGridAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExtentRCBPartitioner(*mut core::ffi::c_void); impl vtkExtentRCBPartitioner { - /// Creates a new [vtkExtentRCBPartitioner] wrapped inside `vtkNew` + /// Creates a new [vtkExtentRCBPartitioner] via `vtkExtentRCBPartitioner::New()` #[doc(alias = "vtkExtentRCBPartitioner")] pub fn new() -> Self { unsafe extern "C" { fn vtkExtentRCBPartitioner_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExtentRCBPartitioner_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExtentRCBPartitioner_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExtentRCBPartitioner_get_ptr(self.0) } + Self(unsafe { vtkExtentRCBPartitioner_new() }) } } impl std::default::Default for vtkExtentRCBPartitioner { @@ -855,12 +6522,8 @@ impl Drop for vtkExtentRCBPartitioner { #[test] fn test_vtkExtentRCBPartitioner_create_drop() { let obj = vtkExtentRCBPartitioner::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExtentRCBPartitioner(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Split an extent across other extents. /// @@ -876,22 +6539,13 @@ fn test_vtkExtentRCBPartitioner_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExtentSplitter(*mut core::ffi::c_void); impl vtkExtentSplitter { - /// Creates a new [vtkExtentSplitter] wrapped inside `vtkNew` + /// Creates a new [vtkExtentSplitter] via `vtkExtentSplitter::New()` #[doc(alias = "vtkExtentSplitter")] pub fn new() -> Self { unsafe extern "C" { fn vtkExtentSplitter_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExtentSplitter_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExtentSplitter_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExtentSplitter_get_ptr(self.0) } + Self(unsafe { vtkExtentSplitter_new() }) } } impl std::default::Default for vtkExtentSplitter { @@ -911,12 +6565,8 @@ impl Drop for vtkExtentSplitter { #[test] fn test_vtkExtentSplitter_create_drop() { let obj = vtkExtentSplitter::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExtentSplitter(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Generates a structured extent from unstructured. /// @@ -928,22 +6578,13 @@ fn test_vtkExtentSplitter_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExtentTranslator(*mut core::ffi::c_void); impl vtkExtentTranslator { - /// Creates a new [vtkExtentTranslator] wrapped inside `vtkNew` + /// Creates a new [vtkExtentTranslator] via `vtkExtentTranslator::New()` #[doc(alias = "vtkExtentTranslator")] pub fn new() -> Self { unsafe extern "C" { fn vtkExtentTranslator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExtentTranslator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExtentTranslator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExtentTranslator_get_ptr(self.0) } + Self(unsafe { vtkExtentTranslator_new() }) } } impl std::default::Default for vtkExtentTranslator { @@ -963,12 +6604,8 @@ impl Drop for vtkExtentTranslator { #[test] fn test_vtkExtentTranslator_create_drop() { let obj = vtkExtentTranslator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExtentTranslator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only graph as output /// @@ -992,22 +6629,13 @@ fn test_vtkExtentTranslator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGraphAlgorithm(*mut core::ffi::c_void); impl vtkGraphAlgorithm { - /// Creates a new [vtkGraphAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkGraphAlgorithm] via `vtkGraphAlgorithm::New()` #[doc(alias = "vtkGraphAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkGraphAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGraphAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGraphAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGraphAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkGraphAlgorithm_new() }) } } impl std::default::Default for vtkGraphAlgorithm { @@ -1027,12 +6655,8 @@ impl Drop for vtkGraphAlgorithm { #[test] fn test_vtkGraphAlgorithm_create_drop() { let obj = vtkGraphAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGraphAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// superclass for algorithms that /// @@ -1044,22 +6668,13 @@ fn test_vtkGraphAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHierarchicalBoxDataSetAlgorithm(*mut core::ffi::c_void); impl vtkHierarchicalBoxDataSetAlgorithm { - /// Creates a new [vtkHierarchicalBoxDataSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkHierarchicalBoxDataSetAlgorithm] via `vtkHierarchicalBoxDataSetAlgorithm::New()` #[doc(alias = "vtkHierarchicalBoxDataSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkHierarchicalBoxDataSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHierarchicalBoxDataSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHierarchicalBoxDataSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkHierarchicalBoxDataSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkHierarchicalBoxDataSetAlgorithm_new() }) } } impl std::default::Default for vtkHierarchicalBoxDataSetAlgorithm { @@ -1081,12 +6696,8 @@ impl Drop for vtkHierarchicalBoxDataSetAlgorithm { #[test] fn test_vtkHierarchicalBoxDataSetAlgorithm_create_drop() { let obj = vtkHierarchicalBoxDataSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHierarchicalBoxDataSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// a structured grid instance. @@ -1097,22 +6708,13 @@ fn test_vtkHierarchicalBoxDataSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImageToStructuredGrid(*mut core::ffi::c_void); impl vtkImageToStructuredGrid { - /// Creates a new [vtkImageToStructuredGrid] wrapped inside `vtkNew` + /// Creates a new [vtkImageToStructuredGrid] via `vtkImageToStructuredGrid::New()` #[doc(alias = "vtkImageToStructuredGrid")] pub fn new() -> Self { unsafe extern "C" { fn vtkImageToStructuredGrid_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImageToStructuredGrid_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImageToStructuredGrid_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImageToStructuredGrid_get_ptr(self.0) } + Self(unsafe { vtkImageToStructuredGrid_new() }) } } impl std::default::Default for vtkImageToStructuredGrid { @@ -1132,12 +6734,8 @@ impl Drop for vtkImageToStructuredGrid { #[test] fn test_vtkImageToStructuredGrid_create_drop() { let obj = vtkImageToStructuredGrid::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImageToStructuredGrid(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Attaches image pipeline to VTK. /// @@ -1151,22 +6749,13 @@ fn test_vtkImageToStructuredGrid_create_drop() { #[allow(non_camel_case_types)] pub struct vtkImageToStructuredPoints(*mut core::ffi::c_void); impl vtkImageToStructuredPoints { - /// Creates a new [vtkImageToStructuredPoints] wrapped inside `vtkNew` + /// Creates a new [vtkImageToStructuredPoints] via `vtkImageToStructuredPoints::New()` #[doc(alias = "vtkImageToStructuredPoints")] pub fn new() -> Self { unsafe extern "C" { fn vtkImageToStructuredPoints_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkImageToStructuredPoints_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkImageToStructuredPoints_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkImageToStructuredPoints_get_ptr(self.0) } + Self(unsafe { vtkImageToStructuredPoints_new() }) } } impl std::default::Default for vtkImageToStructuredPoints { @@ -1186,12 +6775,8 @@ impl Drop for vtkImageToStructuredPoints { #[test] fn test_vtkImageToStructuredPoints_create_drop() { let obj = vtkImageToStructuredPoints::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkImageToStructuredPoints(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that operate on /// @@ -1211,22 +6796,13 @@ fn test_vtkImageToStructuredPoints_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMoleculeAlgorithm(*mut core::ffi::c_void); impl vtkMoleculeAlgorithm { - /// Creates a new [vtkMoleculeAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkMoleculeAlgorithm] via `vtkMoleculeAlgorithm::New()` #[doc(alias = "vtkMoleculeAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkMoleculeAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMoleculeAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMoleculeAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMoleculeAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkMoleculeAlgorithm_new() }) } } impl std::default::Default for vtkMoleculeAlgorithm { @@ -1246,12 +6822,8 @@ impl Drop for vtkMoleculeAlgorithm { #[test] fn test_vtkMoleculeAlgorithm_create_drop() { let obj = vtkMoleculeAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMoleculeAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only vtkMultiBlockDataSet as output /// @@ -1262,22 +6834,13 @@ fn test_vtkMoleculeAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiBlockDataSetAlgorithm(*mut core::ffi::c_void); impl vtkMultiBlockDataSetAlgorithm { - /// Creates a new [vtkMultiBlockDataSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkMultiBlockDataSetAlgorithm] via `vtkMultiBlockDataSetAlgorithm::New()` #[doc(alias = "vtkMultiBlockDataSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiBlockDataSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiBlockDataSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiBlockDataSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiBlockDataSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkMultiBlockDataSetAlgorithm_new() }) } } impl std::default::Default for vtkMultiBlockDataSetAlgorithm { @@ -1297,12 +6860,8 @@ impl Drop for vtkMultiBlockDataSetAlgorithm { #[test] fn test_vtkMultiBlockDataSetAlgorithm_create_drop() { let obj = vtkMultiBlockDataSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiBlockDataSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that would like to make multiple time requests /// @@ -1327,22 +6886,13 @@ fn test_vtkMultiBlockDataSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMultiTimeStepAlgorithm(*mut core::ffi::c_void); impl vtkMultiTimeStepAlgorithm { - /// Creates a new [vtkMultiTimeStepAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkMultiTimeStepAlgorithm] via `vtkMultiTimeStepAlgorithm::New()` #[doc(alias = "vtkMultiTimeStepAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkMultiTimeStepAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMultiTimeStepAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMultiTimeStepAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMultiTimeStepAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkMultiTimeStepAlgorithm_new() }) } } impl std::default::Default for vtkMultiTimeStepAlgorithm { @@ -1362,34 +6912,21 @@ impl Drop for vtkMultiTimeStepAlgorithm { #[test] fn test_vtkMultiTimeStepAlgorithm_create_drop() { let obj = vtkMultiTimeStepAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMultiTimeStepAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// produce vtkNonOverlappingAMR as output. #[allow(non_camel_case_types)] pub struct vtkNonOverlappingAMRAlgorithm(*mut core::ffi::c_void); impl vtkNonOverlappingAMRAlgorithm { - /// Creates a new [vtkNonOverlappingAMRAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkNonOverlappingAMRAlgorithm] via `vtkNonOverlappingAMRAlgorithm::New()` #[doc(alias = "vtkNonOverlappingAMRAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkNonOverlappingAMRAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkNonOverlappingAMRAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkNonOverlappingAMRAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkNonOverlappingAMRAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkNonOverlappingAMRAlgorithm_new() }) } } impl std::default::Default for vtkNonOverlappingAMRAlgorithm { @@ -1409,12 +6946,8 @@ impl Drop for vtkNonOverlappingAMRAlgorithm { #[test] fn test_vtkNonOverlappingAMRAlgorithm_create_drop() { let obj = vtkNonOverlappingAMRAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkNonOverlappingAMRAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A base class for all algorithms that take as input vtkOverlappingAMR and /// @@ -1422,22 +6955,13 @@ fn test_vtkNonOverlappingAMRAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkOverlappingAMRAlgorithm(*mut core::ffi::c_void); impl vtkOverlappingAMRAlgorithm { - /// Creates a new [vtkOverlappingAMRAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkOverlappingAMRAlgorithm] via `vtkOverlappingAMRAlgorithm::New()` #[doc(alias = "vtkOverlappingAMRAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkOverlappingAMRAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkOverlappingAMRAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkOverlappingAMRAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkOverlappingAMRAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkOverlappingAMRAlgorithm_new() }) } } impl std::default::Default for vtkOverlappingAMRAlgorithm { @@ -1457,12 +6981,8 @@ impl Drop for vtkOverlappingAMRAlgorithm { #[test] fn test_vtkOverlappingAMRAlgorithm_create_drop() { let obj = vtkOverlappingAMRAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkOverlappingAMRAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce output of the same type as input /// @@ -1483,22 +7003,13 @@ fn test_vtkOverlappingAMRAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPassInputTypeAlgorithm(*mut core::ffi::c_void); impl vtkPassInputTypeAlgorithm { - /// Creates a new [vtkPassInputTypeAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkPassInputTypeAlgorithm] via `vtkPassInputTypeAlgorithm::New()` #[doc(alias = "vtkPassInputTypeAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkPassInputTypeAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPassInputTypeAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPassInputTypeAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPassInputTypeAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkPassInputTypeAlgorithm_new() }) } } impl std::default::Default for vtkPassInputTypeAlgorithm { @@ -1518,12 +7029,8 @@ impl Drop for vtkPassInputTypeAlgorithm { #[test] fn test_vtkPassInputTypeAlgorithm_create_drop() { let obj = vtkPassInputTypeAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPassInputTypeAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only piecewise function as output /// @@ -1543,22 +7050,13 @@ fn test_vtkPassInputTypeAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPiecewiseFunctionAlgorithm(*mut core::ffi::c_void); impl vtkPiecewiseFunctionAlgorithm { - /// Creates a new [vtkPiecewiseFunctionAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkPiecewiseFunctionAlgorithm] via `vtkPiecewiseFunctionAlgorithm::New()` #[doc(alias = "vtkPiecewiseFunctionAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkPiecewiseFunctionAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPiecewiseFunctionAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPiecewiseFunctionAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPiecewiseFunctionAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkPiecewiseFunctionAlgorithm_new() }) } } impl std::default::Default for vtkPiecewiseFunctionAlgorithm { @@ -1578,33 +7076,20 @@ impl Drop for vtkPiecewiseFunctionAlgorithm { #[test] fn test_vtkPiecewiseFunctionAlgorithm_create_drop() { let obj = vtkPiecewiseFunctionAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPiecewiseFunctionAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// #[allow(non_camel_case_types)] pub struct vtkPiecewiseFunctionShiftScale(*mut core::ffi::c_void); impl vtkPiecewiseFunctionShiftScale { - /// Creates a new [vtkPiecewiseFunctionShiftScale] wrapped inside `vtkNew` + /// Creates a new [vtkPiecewiseFunctionShiftScale] via `vtkPiecewiseFunctionShiftScale::New()` #[doc(alias = "vtkPiecewiseFunctionShiftScale")] pub fn new() -> Self { unsafe extern "C" { fn vtkPiecewiseFunctionShiftScale_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPiecewiseFunctionShiftScale_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPiecewiseFunctionShiftScale_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPiecewiseFunctionShiftScale_get_ptr(self.0) } + Self(unsafe { vtkPiecewiseFunctionShiftScale_new() }) } } impl std::default::Default for vtkPiecewiseFunctionShiftScale { @@ -1624,12 +7109,8 @@ impl Drop for vtkPiecewiseFunctionShiftScale { #[test] fn test_vtkPiecewiseFunctionShiftScale_create_drop() { let obj = vtkPiecewiseFunctionShiftScale::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPiecewiseFunctionShiftScale(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce output of the same type as input /// @@ -1648,22 +7129,13 @@ fn test_vtkPiecewiseFunctionShiftScale_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPointSetAlgorithm(*mut core::ffi::c_void); impl vtkPointSetAlgorithm { - /// Creates a new [vtkPointSetAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkPointSetAlgorithm] via `vtkPointSetAlgorithm::New()` #[doc(alias = "vtkPointSetAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkPointSetAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPointSetAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPointSetAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPointSetAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkPointSetAlgorithm_new() }) } } impl std::default::Default for vtkPointSetAlgorithm { @@ -1683,12 +7155,8 @@ impl Drop for vtkPointSetAlgorithm { #[test] fn test_vtkPointSetAlgorithm_create_drop() { let obj = vtkPointSetAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPointSetAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only polydata as output /// @@ -1706,22 +7174,13 @@ fn test_vtkPointSetAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolyDataAlgorithm(*mut core::ffi::c_void); impl vtkPolyDataAlgorithm { - /// Creates a new [vtkPolyDataAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkPolyDataAlgorithm] via `vtkPolyDataAlgorithm::New()` #[doc(alias = "vtkPolyDataAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolyDataAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolyDataAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolyDataAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolyDataAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkPolyDataAlgorithm_new() }) } } impl std::default::Default for vtkPolyDataAlgorithm { @@ -1741,12 +7200,8 @@ impl Drop for vtkPolyDataAlgorithm { #[test] fn test_vtkPolyDataAlgorithm_create_drop() { let obj = vtkPolyDataAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolyDataAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Basic class to optionally replace vtkAlgorithm progress functionality. /// @@ -1763,22 +7218,13 @@ fn test_vtkPolyDataAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkProgressObserver(*mut core::ffi::c_void); impl vtkProgressObserver { - /// Creates a new [vtkProgressObserver] wrapped inside `vtkNew` + /// Creates a new [vtkProgressObserver] via `vtkProgressObserver::New()` #[doc(alias = "vtkProgressObserver")] pub fn new() -> Self { unsafe extern "C" { fn vtkProgressObserver_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkProgressObserver_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkProgressObserver_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkProgressObserver_get_ptr(self.0) } + Self(unsafe { vtkProgressObserver_new() }) } } impl std::default::Default for vtkProgressObserver { @@ -1798,12 +7244,8 @@ impl Drop for vtkProgressObserver { #[test] fn test_vtkProgressObserver_create_drop() { let obj = vtkProgressObserver::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkProgressObserver(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive that works with vtkReaderAlgorithm and subclasses. /// @@ -1823,22 +7265,13 @@ fn test_vtkProgressObserver_create_drop() { #[allow(non_camel_case_types)] pub struct vtkReaderExecutive(*mut core::ffi::c_void); impl vtkReaderExecutive { - /// Creates a new [vtkReaderExecutive] wrapped inside `vtkNew` + /// Creates a new [vtkReaderExecutive] via `vtkReaderExecutive::New()` #[doc(alias = "vtkReaderExecutive")] pub fn new() -> Self { unsafe extern "C" { fn vtkReaderExecutive_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkReaderExecutive_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkReaderExecutive_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkReaderExecutive_get_ptr(self.0) } + Self(unsafe { vtkReaderExecutive_new() }) } } impl std::default::Default for vtkReaderExecutive { @@ -1858,12 +7291,8 @@ impl Drop for vtkReaderExecutive { #[test] fn test_vtkReaderExecutive_create_drop() { let obj = vtkReaderExecutive::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkReaderExecutive(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only rectilinear grid as output /// @@ -1883,22 +7312,13 @@ fn test_vtkReaderExecutive_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRectilinearGridAlgorithm(*mut core::ffi::c_void); impl vtkRectilinearGridAlgorithm { - /// Creates a new [vtkRectilinearGridAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkRectilinearGridAlgorithm] via `vtkRectilinearGridAlgorithm::New()` #[doc(alias = "vtkRectilinearGridAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkRectilinearGridAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRectilinearGridAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRectilinearGridAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRectilinearGridAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkRectilinearGridAlgorithm_new() }) } } impl std::default::Default for vtkRectilinearGridAlgorithm { @@ -1918,12 +7338,8 @@ impl Drop for vtkRectilinearGridAlgorithm { #[test] fn test_vtkRectilinearGridAlgorithm_create_drop() { let obj = vtkRectilinearGridAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRectilinearGridAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Progress observer that is thread safe /// @@ -1937,22 +7353,13 @@ fn test_vtkRectilinearGridAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSMPProgressObserver(*mut core::ffi::c_void); impl vtkSMPProgressObserver { - /// Creates a new [vtkSMPProgressObserver] wrapped inside `vtkNew` + /// Creates a new [vtkSMPProgressObserver] via `vtkSMPProgressObserver::New()` #[doc(alias = "vtkSMPProgressObserver")] pub fn new() -> Self { unsafe extern "C" { fn vtkSMPProgressObserver_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSMPProgressObserver_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSMPProgressObserver_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSMPProgressObserver_get_ptr(self.0) } + Self(unsafe { vtkSMPProgressObserver_new() }) } } impl std::default::Default for vtkSMPProgressObserver { @@ -1972,12 +7379,8 @@ impl Drop for vtkSMPProgressObserver { #[test] fn test_vtkSMPProgressObserver_create_drop() { let obj = vtkSMPProgressObserver::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSMPProgressObserver(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only Selection as output /// @@ -2001,22 +7404,13 @@ fn test_vtkSMPProgressObserver_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSelectionAlgorithm(*mut core::ffi::c_void); impl vtkSelectionAlgorithm { - /// Creates a new [vtkSelectionAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkSelectionAlgorithm] via `vtkSelectionAlgorithm::New()` #[doc(alias = "vtkSelectionAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkSelectionAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSelectionAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSelectionAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSelectionAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkSelectionAlgorithm_new() }) } } impl std::default::Default for vtkSelectionAlgorithm { @@ -2036,12 +7430,8 @@ impl Drop for vtkSelectionAlgorithm { #[test] fn test_vtkSelectionAlgorithm_create_drop() { let obj = vtkSelectionAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSelectionAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// organize data according to scalar values (used to accelerate contouring operations) /// @@ -2075,22 +7465,13 @@ fn test_vtkSelectionAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSimpleScalarTree(*mut core::ffi::c_void); impl vtkSimpleScalarTree { - /// Creates a new [vtkSimpleScalarTree] wrapped inside `vtkNew` + /// Creates a new [vtkSimpleScalarTree] via `vtkSimpleScalarTree::New()` #[doc(alias = "vtkSimpleScalarTree")] pub fn new() -> Self { unsafe extern "C" { fn vtkSimpleScalarTree_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSimpleScalarTree_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSimpleScalarTree_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSimpleScalarTree_get_ptr(self.0) } + Self(unsafe { vtkSimpleScalarTree_new() }) } } impl std::default::Default for vtkSimpleScalarTree { @@ -2110,12 +7491,8 @@ impl Drop for vtkSimpleScalarTree { #[test] fn test_vtkSimpleScalarTree_create_drop() { let obj = vtkSimpleScalarTree::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSimpleScalarTree(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// organize data according to scalar span space /// @@ -2141,22 +7518,13 @@ fn test_vtkSimpleScalarTree_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSpanSpace(*mut core::ffi::c_void); impl vtkSpanSpace { - /// Creates a new [vtkSpanSpace] wrapped inside `vtkNew` + /// Creates a new [vtkSpanSpace] via `vtkSpanSpace::New()` #[doc(alias = "vtkSpanSpace")] pub fn new() -> Self { unsafe extern "C" { fn vtkSpanSpace_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSpanSpace_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSpanSpace_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSpanSpace_get_ptr(self.0) } + Self(unsafe { vtkSpanSpace_new() }) } } impl std::default::Default for vtkSpanSpace { @@ -2176,12 +7544,8 @@ impl Drop for vtkSpanSpace { #[test] fn test_vtkSpanSpace_create_drop() { let obj = vtkSpanSpace::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSpanSpace(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// class to build and traverse sphere trees /// @@ -2217,22 +7581,13 @@ fn test_vtkSpanSpace_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSphereTree(*mut core::ffi::c_void); impl vtkSphereTree { - /// Creates a new [vtkSphereTree] wrapped inside `vtkNew` + /// Creates a new [vtkSphereTree] via `vtkSphereTree::New()` #[doc(alias = "vtkSphereTree")] pub fn new() -> Self { unsafe extern "C" { fn vtkSphereTree_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSphereTree_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSphereTree_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSphereTree_get_ptr(self.0) } + Self(unsafe { vtkSphereTree_new() }) } } impl std::default::Default for vtkSphereTree { @@ -2252,12 +7607,8 @@ impl Drop for vtkSphereTree { #[test] fn test_vtkSphereTree_create_drop() { let obj = vtkSphereTree::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSphereTree(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive supporting partial updates. /// @@ -2270,22 +7621,13 @@ fn test_vtkSphereTree_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStreamingDemandDrivenPipeline(*mut core::ffi::c_void); impl vtkStreamingDemandDrivenPipeline { - /// Creates a new [vtkStreamingDemandDrivenPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkStreamingDemandDrivenPipeline] via `vtkStreamingDemandDrivenPipeline::New()` #[doc(alias = "vtkStreamingDemandDrivenPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkStreamingDemandDrivenPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStreamingDemandDrivenPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStreamingDemandDrivenPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStreamingDemandDrivenPipeline_get_ptr(self.0) } + Self(unsafe { vtkStreamingDemandDrivenPipeline_new() }) } } impl std::default::Default for vtkStreamingDemandDrivenPipeline { @@ -2307,12 +7649,8 @@ impl Drop for vtkStreamingDemandDrivenPipeline { #[test] fn test_vtkStreamingDemandDrivenPipeline_create_drop() { let obj = vtkStreamingDemandDrivenPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStreamingDemandDrivenPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only structured grid as output /// @@ -2330,22 +7668,13 @@ fn test_vtkStreamingDemandDrivenPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkStructuredGridAlgorithm(*mut core::ffi::c_void); impl vtkStructuredGridAlgorithm { - /// Creates a new [vtkStructuredGridAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkStructuredGridAlgorithm] via `vtkStructuredGridAlgorithm::New()` #[doc(alias = "vtkStructuredGridAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkStructuredGridAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkStructuredGridAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkStructuredGridAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkStructuredGridAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkStructuredGridAlgorithm_new() }) } } impl std::default::Default for vtkStructuredGridAlgorithm { @@ -2365,12 +7694,8 @@ impl Drop for vtkStructuredGridAlgorithm { #[test] fn test_vtkStructuredGridAlgorithm_create_drop() { let obj = vtkStructuredGridAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkStructuredGridAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only vtkTables as output /// @@ -2391,22 +7716,13 @@ fn test_vtkStructuredGridAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTableAlgorithm(*mut core::ffi::c_void); impl vtkTableAlgorithm { - /// Creates a new [vtkTableAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkTableAlgorithm] via `vtkTableAlgorithm::New()` #[doc(alias = "vtkTableAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkTableAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTableAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTableAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTableAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkTableAlgorithm_new() }) } } impl std::default::Default for vtkTableAlgorithm { @@ -2426,12 +7742,8 @@ impl Drop for vtkTableAlgorithm { #[test] fn test_vtkTableAlgorithm_create_drop() { let obj = vtkTableAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTableAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Executive that works in parallel /// @@ -2446,22 +7758,13 @@ fn test_vtkTableAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkThreadedCompositeDataPipeline(*mut core::ffi::c_void); impl vtkThreadedCompositeDataPipeline { - /// Creates a new [vtkThreadedCompositeDataPipeline] wrapped inside `vtkNew` + /// Creates a new [vtkThreadedCompositeDataPipeline] via `vtkThreadedCompositeDataPipeline::New()` #[doc(alias = "vtkThreadedCompositeDataPipeline")] pub fn new() -> Self { unsafe extern "C" { fn vtkThreadedCompositeDataPipeline_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkThreadedCompositeDataPipeline_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkThreadedCompositeDataPipeline_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkThreadedCompositeDataPipeline_get_ptr(self.0) } + Self(unsafe { vtkThreadedCompositeDataPipeline_new() }) } } impl std::default::Default for vtkThreadedCompositeDataPipeline { @@ -2483,12 +7786,8 @@ impl Drop for vtkThreadedCompositeDataPipeline { #[test] fn test_vtkThreadedCompositeDataPipeline_create_drop() { let obj = vtkThreadedCompositeDataPipeline::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkThreadedCompositeDataPipeline(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only Tree as output /// @@ -2506,22 +7805,13 @@ fn test_vtkThreadedCompositeDataPipeline_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTreeAlgorithm(*mut core::ffi::c_void); impl vtkTreeAlgorithm { - /// Creates a new [vtkTreeAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkTreeAlgorithm] via `vtkTreeAlgorithm::New()` #[doc(alias = "vtkTreeAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkTreeAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTreeAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTreeAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTreeAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkTreeAlgorithm_new() }) } } impl std::default::Default for vtkTreeAlgorithm { @@ -2541,12 +7831,8 @@ impl Drop for vtkTreeAlgorithm { #[test] fn test_vtkTreeAlgorithm_create_drop() { let obj = vtkTreeAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTreeAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Consumer to consume data off of a pipeline. /// @@ -2558,22 +7844,13 @@ fn test_vtkTreeAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTrivialConsumer(*mut core::ffi::c_void); impl vtkTrivialConsumer { - /// Creates a new [vtkTrivialConsumer] wrapped inside `vtkNew` + /// Creates a new [vtkTrivialConsumer] via `vtkTrivialConsumer::New()` #[doc(alias = "vtkTrivialConsumer")] pub fn new() -> Self { unsafe extern "C" { fn vtkTrivialConsumer_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTrivialConsumer_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTrivialConsumer_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTrivialConsumer_get_ptr(self.0) } + Self(unsafe { vtkTrivialConsumer_new() }) } } impl std::default::Default for vtkTrivialConsumer { @@ -2593,12 +7870,8 @@ impl Drop for vtkTrivialConsumer { #[test] fn test_vtkTrivialConsumer_create_drop() { let obj = vtkTrivialConsumer::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTrivialConsumer(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Producer for stand-alone data objects. /// @@ -2611,22 +7884,13 @@ fn test_vtkTrivialConsumer_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTrivialProducer(*mut core::ffi::c_void); impl vtkTrivialProducer { - /// Creates a new [vtkTrivialProducer] wrapped inside `vtkNew` + /// Creates a new [vtkTrivialProducer] via `vtkTrivialProducer::New()` #[doc(alias = "vtkTrivialProducer")] pub fn new() -> Self { unsafe extern "C" { fn vtkTrivialProducer_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTrivialProducer_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTrivialProducer_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTrivialProducer_get_ptr(self.0) } + Self(unsafe { vtkTrivialProducer_new() }) } } impl std::default::Default for vtkTrivialProducer { @@ -2646,12 +7910,8 @@ impl Drop for vtkTrivialProducer { #[test] fn test_vtkTrivialProducer_create_drop() { let obj = vtkTrivialProducer::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTrivialProducer(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce undirected graph as output /// @@ -2673,22 +7933,13 @@ fn test_vtkTrivialProducer_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUndirectedGraphAlgorithm(*mut core::ffi::c_void); impl vtkUndirectedGraphAlgorithm { - /// Creates a new [vtkUndirectedGraphAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkUndirectedGraphAlgorithm] via `vtkUndirectedGraphAlgorithm::New()` #[doc(alias = "vtkUndirectedGraphAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkUndirectedGraphAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUndirectedGraphAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUndirectedGraphAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUndirectedGraphAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkUndirectedGraphAlgorithm_new() }) } } impl std::default::Default for vtkUndirectedGraphAlgorithm { @@ -2708,12 +7959,8 @@ impl Drop for vtkUndirectedGraphAlgorithm { #[test] fn test_vtkUndirectedGraphAlgorithm_create_drop() { let obj = vtkUndirectedGraphAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUndirectedGraphAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// vtkUniformGridAMR as output. @@ -2724,22 +7971,13 @@ fn test_vtkUndirectedGraphAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformGridAMRAlgorithm(*mut core::ffi::c_void); impl vtkUniformGridAMRAlgorithm { - /// Creates a new [vtkUniformGridAMRAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGridAMRAlgorithm] via `vtkUniformGridAMRAlgorithm::New()` #[doc(alias = "vtkUniformGridAMRAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGridAMRAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGridAMRAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGridAMRAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGridAMRAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkUniformGridAMRAlgorithm_new() }) } } impl std::default::Default for vtkUniformGridAMRAlgorithm { @@ -2759,12 +7997,8 @@ impl Drop for vtkUniformGridAMRAlgorithm { #[test] fn test_vtkUniformGridAMRAlgorithm_create_drop() { let obj = vtkUniformGridAMRAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGridAMRAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// /// A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides @@ -2777,22 +8011,13 @@ fn test_vtkUniformGridAMRAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUniformGridPartitioner(*mut core::ffi::c_void); impl vtkUniformGridPartitioner { - /// Creates a new [vtkUniformGridPartitioner] wrapped inside `vtkNew` + /// Creates a new [vtkUniformGridPartitioner] via `vtkUniformGridPartitioner::New()` #[doc(alias = "vtkUniformGridPartitioner")] pub fn new() -> Self { unsafe extern "C" { fn vtkUniformGridPartitioner_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUniformGridPartitioner_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUniformGridPartitioner_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUniformGridPartitioner_get_ptr(self.0) } + Self(unsafe { vtkUniformGridPartitioner_new() }) } } impl std::default::Default for vtkUniformGridPartitioner { @@ -2812,12 +8037,8 @@ impl Drop for vtkUniformGridPartitioner { #[test] fn test_vtkUniformGridPartitioner_create_drop() { let obj = vtkUniformGridPartitioner::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUniformGridPartitioner(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that produce only unstructured grid as output /// @@ -2835,22 +8056,13 @@ fn test_vtkUniformGridPartitioner_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnstructuredGridAlgorithm(*mut core::ffi::c_void); impl vtkUnstructuredGridAlgorithm { - /// Creates a new [vtkUnstructuredGridAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkUnstructuredGridAlgorithm] via `vtkUnstructuredGridAlgorithm::New()` #[doc(alias = "vtkUnstructuredGridAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnstructuredGridAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnstructuredGridAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnstructuredGridAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnstructuredGridAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkUnstructuredGridAlgorithm_new() }) } } impl std::default::Default for vtkUnstructuredGridAlgorithm { @@ -2870,12 +8082,8 @@ impl Drop for vtkUnstructuredGridAlgorithm { #[test] fn test_vtkUnstructuredGridAlgorithm_create_drop() { let obj = vtkUnstructuredGridAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnstructuredGridAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Superclass for algorithms that /// @@ -2892,22 +8100,13 @@ fn test_vtkUnstructuredGridAlgorithm_create_drop() { #[allow(non_camel_case_types)] pub struct vtkUnstructuredGridBaseAlgorithm(*mut core::ffi::c_void); impl vtkUnstructuredGridBaseAlgorithm { - /// Creates a new [vtkUnstructuredGridBaseAlgorithm] wrapped inside `vtkNew` + /// Creates a new [vtkUnstructuredGridBaseAlgorithm] via `vtkUnstructuredGridBaseAlgorithm::New()` #[doc(alias = "vtkUnstructuredGridBaseAlgorithm")] pub fn new() -> Self { unsafe extern "C" { fn vtkUnstructuredGridBaseAlgorithm_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkUnstructuredGridBaseAlgorithm_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkUnstructuredGridBaseAlgorithm_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkUnstructuredGridBaseAlgorithm_get_ptr(self.0) } + Self(unsafe { vtkUnstructuredGridBaseAlgorithm_new() }) } } impl std::default::Default for vtkUnstructuredGridBaseAlgorithm { @@ -2929,10 +8128,6 @@ impl Drop for vtkUnstructuredGridBaseAlgorithm { #[test] fn test_vtkUnstructuredGridBaseAlgorithm_create_drop() { let obj = vtkUnstructuredGridBaseAlgorithm::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkUnstructuredGridBaseAlgorithm(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonMath.rs b/vtk-rs-9.1/src/vtkCommonMath.rs index 4d14109..3910274 100644 --- a/vtk-rs-9.1/src/vtkCommonMath.rs +++ b/vtk-rs-9.1/src/vtkCommonMath.rs @@ -1,3 +1,1068 @@ +pub trait VtkAmoebaMinimizer { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_function_arg_delete(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_parameter_value(&mut self, name: &str, value: core::ffi::c_double) -> (); + fn set_parameter_scale(&mut self, name: &str, scale: core::ffi::c_double) -> (); + fn get_parameter_scale(&mut self, name: &str) -> core::ffi::c_double; + fn get_parameter_value(&mut self, name: &str) -> core::ffi::c_double; + fn get_parameter_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_number_of_parameters(&mut self) -> core::ffi::c_int; + fn initialize(&mut self) -> (); + fn minimize(&mut self) -> (); + fn iterate(&mut self) -> core::ffi::c_int; + fn set_function_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_function_value(&mut self) -> core::ffi::c_double; + fn set_contraction_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_contraction_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_contraction_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_contraction_ratio(&mut self) -> core::ffi::c_double; + fn set_expansion_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_expansion_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_expansion_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_expansion_ratio(&mut self) -> core::ffi::c_double; + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tolerance(&mut self) -> core::ffi::c_double; + fn set_parameter_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_parameter_tolerance(&mut self) -> core::ffi::c_double; + fn set_max_iterations(&mut self, _arg: core::ffi::c_int) -> (); + fn get_max_iterations(&mut self) -> core::ffi::c_int; + fn get_iterations(&mut self) -> core::ffi::c_int; + fn get_function_evaluations(&mut self) -> core::ffi::c_int; + fn evaluate_function(&mut self) -> (); +} +pub trait VtkFFT { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn hanning_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; + fn bartlett_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; + fn sine_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; + fn blackman_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; + fn rectangular_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double; +} +pub trait VtkFunctionSet { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_functions(&mut self) -> core::ffi::c_int; + fn get_number_of_independent_variables(&mut self) -> core::ffi::c_int; +} +pub trait VtkInitialValueProblemSolver { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_function_set(&mut self, fset: *mut core::ffi::c_void) -> (); + fn get_function_set(&mut self) -> *mut core::ffi::c_void; + fn is_adaptive(&mut self) -> core::ffi::c_int; +} +pub trait VtkMatrix3x3 { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn deep_copy(&mut self, source: *mut core::ffi::c_void) -> (); + fn zero(&mut self) -> (); + fn identity(&mut self) -> (); + fn invert(&mut self, in_: *mut core::ffi::c_void, out: *mut core::ffi::c_void) -> (); + fn transpose( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> (); + fn multiply_3_x_3( + &mut self, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ) -> (); + fn adjoint( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> (); + fn determinant(&mut self) -> core::ffi::c_double; + fn set_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; + fn is_identity(&mut self) -> bool; +} +pub trait VtkMatrix4x4 { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn zero(&mut self) -> (); + fn identity(&mut self) -> (); + fn is_identity(&mut self) -> bool; + fn determinant(&mut self) -> core::ffi::c_double; + fn set_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; +} +pub trait VtkPolynomialSolversUnivariate { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_division_tolerance(&mut self, tol: core::ffi::c_double) -> (); + fn get_division_tolerance(&mut self) -> core::ffi::c_double; +} +pub trait VtkQuaternion { + fn to_identity(&mut self) -> (); + fn conjugate(&mut self) -> (); + fn invert(&mut self) -> (); + fn to_unit_log(&mut self) -> (); + fn to_unit_exp(&mut self) -> (); + fn normalize_with_angle_in_degrees(&mut self) -> (); +} +pub trait VtkQuaternionInterpolator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_number_of_quaternions(&mut self) -> core::ffi::c_int; + fn get_minimum_t(&mut self) -> core::ffi::c_double; + fn get_maximum_t(&mut self) -> core::ffi::c_double; + fn initialize(&mut self) -> (); + fn remove_quaternion(&mut self, t: core::ffi::c_double) -> (); + fn get_search_method(&mut self) -> core::ffi::c_int; + fn set_search_method(&mut self, type_: core::ffi::c_int) -> (); + fn set_interpolation_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_interpolation_type_min_value(&mut self) -> core::ffi::c_int; + fn get_interpolation_type_max_value(&mut self) -> core::ffi::c_int; + fn get_interpolation_type(&mut self) -> core::ffi::c_int; + fn set_interpolation_type_to_linear(&mut self) -> (); + fn set_interpolation_type_to_spline(&mut self) -> (); +} +pub trait VtkQuaterniond { + fn squared_norm(&mut self) -> core::ffi::c_double; + fn norm(&mut self) -> core::ffi::c_double; + fn normalize(&mut self) -> core::ffi::c_double; + fn set( + &mut self, + w: &core::ffi::c_double, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + z: &core::ffi::c_double, + ) -> (); + fn set_w(&mut self, w: &core::ffi::c_double) -> (); + fn get_w(&mut self) -> core::ffi::c_double; + fn set_x(&mut self, x: &core::ffi::c_double) -> (); + fn get_x(&mut self) -> core::ffi::c_double; + fn set_y(&mut self, y: &core::ffi::c_double) -> (); + fn get_y(&mut self) -> core::ffi::c_double; + fn set_z(&mut self, z: &core::ffi::c_double) -> (); + fn get_z(&mut self) -> core::ffi::c_double; + fn set_rotation_angle_and_axis( + &mut self, + angle: &core::ffi::c_double, + x: &core::ffi::c_double, + y: &core::ffi::c_double, + z: &core::ffi::c_double, + ) -> (); +} +pub trait VtkQuaternionf { + fn squared_norm(&mut self) -> core::ffi::c_float; + fn norm(&mut self) -> core::ffi::c_float; + fn normalize(&mut self) -> core::ffi::c_float; + fn set( + &mut self, + w: &core::ffi::c_float, + x: &core::ffi::c_float, + y: &core::ffi::c_float, + z: &core::ffi::c_float, + ) -> (); + fn set_w(&mut self, w: &core::ffi::c_float) -> (); + fn get_w(&mut self) -> core::ffi::c_float; + fn set_x(&mut self, x: &core::ffi::c_float) -> (); + fn get_x(&mut self) -> core::ffi::c_float; + fn set_y(&mut self, y: &core::ffi::c_float) -> (); + fn get_y(&mut self) -> core::ffi::c_float; + fn set_z(&mut self, z: &core::ffi::c_float) -> (); + fn get_z(&mut self) -> core::ffi::c_float; + fn set_rotation_angle_and_axis( + &mut self, + angle: &core::ffi::c_float, + x: &core::ffi::c_float, + y: &core::ffi::c_float, + z: &core::ffi::c_float, + ) -> (); +} +pub trait VtkRungeKutta2 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkRungeKutta4 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkRungeKutta45 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkTuple { + fn get_size(&mut self) -> core::ffi::c_int; + fn get_data(&mut self) -> *mut core::ffi::c_void; +} +impl VtkAmoebaMinimizer for vtkAmoebaMinimizer { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amoeba_minimizer_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amoeba_minimizer_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amoeba_minimizer_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amoeba_minimizer_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_amoeba_minimizer_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_amoeba_minimizer_new_instance(self.0) } + } + fn set_function_arg_delete(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_function_arg_delete( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_amoeba_minimizer_set_function_arg_delete(self.0, f) } + } + fn set_parameter_value(&mut self, name: &str, value: core::ffi::c_double) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_parameter_value( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_amoeba_minimizer_set_parameter_value(self.0, c_name.as_ptr(), value) + } + } + fn set_parameter_scale(&mut self, name: &str, scale: core::ffi::c_double) -> () { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_parameter_scale( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + scale: core::ffi::c_double, + ); + } + unsafe { + vtk_amoeba_minimizer_set_parameter_scale(self.0, c_name.as_ptr(), scale) + } + } + fn get_parameter_scale(&mut self, name: &str) -> core::ffi::c_double { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_scale( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_parameter_scale(self.0, c_name.as_ptr()) } + } + fn get_parameter_value(&mut self, name: &str) -> core::ffi::c_double { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_value( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_parameter_value(self.0, c_name.as_ptr()) } + } + fn get_parameter_name(&mut self, i: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_amoeba_minimizer_get_parameter_name(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_number_of_parameters(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_number_of_parameters( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_get_number_of_parameters(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_amoeba_minimizer_initialize(self.0) } + } + fn minimize(&mut self) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_minimize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_amoeba_minimizer_minimize(self.0) } + } + fn iterate(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_iterate( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_iterate(self.0) } + } + fn set_function_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_function_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_function_value(self.0, _arg) } + } + fn get_function_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_function_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_function_value(self.0) } + } + fn set_contraction_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_contraction_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_contraction_ratio(self.0, _arg) } + } + fn get_contraction_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_contraction_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_contraction_ratio_min_value(self.0) } + } + fn get_contraction_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_contraction_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_contraction_ratio_max_value(self.0) } + } + fn get_contraction_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_contraction_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_contraction_ratio(self.0) } + } + fn set_expansion_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_expansion_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_expansion_ratio(self.0, _arg) } + } + fn get_expansion_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_expansion_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_expansion_ratio_min_value(self.0) } + } + fn get_expansion_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_expansion_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_expansion_ratio_max_value(self.0) } + } + fn get_expansion_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_expansion_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_expansion_ratio(self.0) } + } + fn set_tolerance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_tolerance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_tolerance(self.0, _arg) } + } + fn get_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_tolerance(self.0) } + } + fn set_parameter_tolerance(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_parameter_tolerance( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_amoeba_minimizer_set_parameter_tolerance(self.0, _arg) } + } + fn get_parameter_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_parameter_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_amoeba_minimizer_get_parameter_tolerance(self.0) } + } + fn set_max_iterations(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_set_max_iterations( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_amoeba_minimizer_set_max_iterations(self.0, _arg) } + } + fn get_max_iterations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_max_iterations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_get_max_iterations(self.0) } + } + fn get_iterations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_iterations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_get_iterations(self.0) } + } + fn get_function_evaluations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_amoeba_minimizer_get_function_evaluations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_amoeba_minimizer_get_function_evaluations(self.0) } + } + fn evaluate_function(&mut self) -> () { + unsafe extern "C" { + fn vtk_amoeba_minimizer_evaluate_function(sself: *mut core::ffi::c_void); + } + unsafe { vtk_amoeba_minimizer_evaluate_function(self.0) } + } +} +impl VtkFFT for vtkFFT { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_fft_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_fft_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_fft_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_fft_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_fft_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_fft_new_instance(self.0) } + } + fn hanning_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_hanning_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_hanning_generator(self.0, x, size) } + } + fn bartlett_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_bartlett_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_bartlett_generator(self.0, x, size) } + } + fn sine_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_sine_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_sine_generator(self.0, x, size) } + } + fn blackman_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_blackman_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_blackman_generator(self.0, x, size) } + } + fn rectangular_generator(&mut self, x: usize, size: usize) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_fft_rectangular_generator( + sself: *mut core::ffi::c_void, + x: usize, + size: usize, + ) -> core::ffi::c_double; + } + unsafe { vtk_fft_rectangular_generator(self.0, x, size) } + } +} +impl VtkMatrix3x3 for vtkMatrix3x3 { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_3_x_3_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_3_x_3_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_3_x_3_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_3_x_3_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_3_x_3_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_3_x_3_new_instance(self.0) } + } + fn deep_copy(&mut self, source: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_deep_copy( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_deep_copy(self.0, source) } + } + fn zero(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_zero(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_3_x_3_zero(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_3_x_3_identity(self.0) } + } + fn invert( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_invert( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_invert(self.0, in_, out) } + } + fn transpose( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_transpose( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_transpose(self.0, in_, out) } + } + fn multiply_3_x_3( + &mut self, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_multiply_3_x_3( + sself: *mut core::ffi::c_void, + a: *mut core::ffi::c_void, + b: *mut core::ffi::c_void, + c: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_multiply_3_x_3(self.0, a, b, c) } + } + fn adjoint( + &mut self, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_adjoint( + sself: *mut core::ffi::c_void, + in_: *mut core::ffi::c_void, + out: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_3_x_3_adjoint(self.0, in_, out) } + } + fn determinant(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_3_x_3_determinant( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_3_x_3_determinant(self.0) } + } + fn set_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_3_x_3_set_element( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_3_x_3_set_element(self.0, i, j, value) } + } + fn get_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_3_x_3_get_element( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_3_x_3_get_element(self.0, i, j) } + } + fn is_identity(&mut self) -> bool { + unsafe extern "C" { + fn vtk_matrix_3_x_3_is_identity(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_matrix_3_x_3_is_identity(self.0) } + } +} +impl VtkMatrix4x4 for vtkMatrix4x4 { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_4_x_4_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_4_x_4_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_4_x_4_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_4_x_4_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_4_x_4_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_4_x_4_new_instance(self.0) } + } + fn zero(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_zero(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_4_x_4_zero(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_4_x_4_identity(self.0) } + } + fn is_identity(&mut self) -> bool { + unsafe extern "C" { + fn vtk_matrix_4_x_4_is_identity(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_matrix_4_x_4_is_identity(self.0) } + } + fn determinant(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_determinant( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_determinant(self.0) } + } + fn set_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_matrix_4_x_4_set_element( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_matrix_4_x_4_set_element(self.0, i, j, value) } + } + fn get_element( + &mut self, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_matrix_4_x_4_get_element( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + j: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_matrix_4_x_4_get_element(self.0, i, j) } + } +} +impl VtkPolynomialSolversUnivariate for vtkPolynomialSolversUnivariate { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polynomial_solvers_univariate_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polynomial_solvers_univariate_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_polynomial_solvers_univariate_new_instance(self.0) } + } + fn set_division_tolerance(&mut self, tol: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_set_division_tolerance( + sself: *mut core::ffi::c_void, + tol: core::ffi::c_double, + ); + } + unsafe { vtk_polynomial_solvers_univariate_set_division_tolerance(self.0, tol) } + } + fn get_division_tolerance(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_polynomial_solvers_univariate_get_division_tolerance( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_polynomial_solvers_univariate_get_division_tolerance(self.0) } + } +} +impl VtkQuaternionInterpolator for vtkQuaternionInterpolator { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quaternion_interpolator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quaternion_interpolator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quaternion_interpolator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quaternion_interpolator_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_quaternion_interpolator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_quaternion_interpolator_new(self.0) } + } + fn get_number_of_quaternions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_number_of_quaternions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_number_of_quaternions(self.0) } + } + fn get_minimum_t(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_minimum_t( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_quaternion_interpolator_get_minimum_t(self.0) } + } + fn get_maximum_t(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_maximum_t( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_quaternion_interpolator_get_maximum_t(self.0) } + } + fn initialize(&mut self) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_initialize(sself: *mut core::ffi::c_void); + } + unsafe { vtk_quaternion_interpolator_initialize(self.0) } + } + fn remove_quaternion(&mut self, t: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_remove_quaternion( + sself: *mut core::ffi::c_void, + t: core::ffi::c_double, + ); + } + unsafe { vtk_quaternion_interpolator_remove_quaternion(self.0, t) } + } + fn get_search_method(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_search_method( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_search_method(self.0) } + } + fn set_search_method(&mut self, type_: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_set_search_method( + sself: *mut core::ffi::c_void, + type_: core::ffi::c_int, + ); + } + unsafe { vtk_quaternion_interpolator_set_search_method(self.0, type_) } + } + fn set_interpolation_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_set_interpolation_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_quaternion_interpolator_set_interpolation_type(self.0, _arg) } + } + fn get_interpolation_type_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_interpolation_type_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_interpolation_type_min_value(self.0) } + } + fn get_interpolation_type_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_interpolation_type_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_interpolation_type_max_value(self.0) } + } + fn get_interpolation_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_quaternion_interpolator_get_interpolation_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_quaternion_interpolator_get_interpolation_type(self.0) } + } + fn set_interpolation_type_to_linear(&mut self) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_set_interpolation_type_to_linear( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_quaternion_interpolator_set_interpolation_type_to_linear(self.0) } + } + fn set_interpolation_type_to_spline(&mut self) -> () { + unsafe extern "C" { + fn vtk_quaternion_interpolator_set_interpolation_type_to_spline( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_quaternion_interpolator_set_interpolation_type_to_spline(self.0) } + } +} +impl VtkRungeKutta2 for vtkRungeKutta2 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_2_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_2_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_2_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_2_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_2_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_2_new(self.0) } + } +} +impl VtkRungeKutta4 for vtkRungeKutta4 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_4_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_4_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_4_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_4_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_4_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_4_new(self.0) } + } +} +impl VtkRungeKutta45 for vtkRungeKutta45 { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_45_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_45_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_45_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_45_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_runge_kutta_45_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_runge_kutta_45_new(self.0) } + } +} /// nonlinear optimization with a simplex /// /// @@ -12,22 +1077,13 @@ #[allow(non_camel_case_types)] pub struct vtkAmoebaMinimizer(*mut core::ffi::c_void); impl vtkAmoebaMinimizer { - /// Creates a new [vtkAmoebaMinimizer] wrapped inside `vtkNew` + /// Creates a new [vtkAmoebaMinimizer] via `vtkAmoebaMinimizer::New()` #[doc(alias = "vtkAmoebaMinimizer")] pub fn new() -> Self { unsafe extern "C" { fn vtkAmoebaMinimizer_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkAmoebaMinimizer_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkAmoebaMinimizer_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkAmoebaMinimizer_get_ptr(self.0) } + Self(unsafe { vtkAmoebaMinimizer_new() }) } } impl std::default::Default for vtkAmoebaMinimizer { @@ -47,12 +1103,8 @@ impl Drop for vtkAmoebaMinimizer { #[test] fn test_vtkAmoebaMinimizer_create_drop() { let obj = vtkAmoebaMinimizer::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkAmoebaMinimizer(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// perform Discrete Fourier Transforms /// @@ -62,26 +1114,19 @@ fn test_vtkAmoebaMinimizer_create_drop() { /// The current implementation uses the third-party library kissfft. /// /// The terminology tries to follow the Numpy terminology, that is : -/// - Fft means the Fast Fourier Transform algorithm +/// - Fft means the Fast Fourier Tranform algorithm /// - Prefix `R` stands for Real (meaning optimized function for real inputs) /// - Prefix `I` stands for Inverse #[allow(non_camel_case_types)] pub struct vtkFFT(*mut core::ffi::c_void); impl vtkFFT { - /// Creates a new [vtkFFT] wrapped inside `vtkNew` + /// Creates a new [vtkFFT] via `vtkFFT::New()` #[doc(alias = "vtkFFT")] pub fn new() -> Self { unsafe extern "C" { fn vtkFFT_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFFT_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFFT_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkFFT_get_ptr(self.0) } + Self(unsafe { vtkFFT_new() }) } } impl std::default::Default for vtkFFT { @@ -101,12 +1146,8 @@ impl Drop for vtkFFT { #[test] fn test_vtkFFT_create_drop() { let obj = vtkFFT::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFFT(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate 3x3 transformation matrices /// @@ -120,22 +1161,13 @@ fn test_vtkFFT_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMatrix3x3(*mut core::ffi::c_void); impl vtkMatrix3x3 { - /// Creates a new [vtkMatrix3x3] wrapped inside `vtkNew` + /// Creates a new [vtkMatrix3x3] via `vtkMatrix3x3::New()` #[doc(alias = "vtkMatrix3x3")] pub fn new() -> Self { unsafe extern "C" { fn vtkMatrix3x3_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMatrix3x3_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMatrix3x3_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMatrix3x3_get_ptr(self.0) } + Self(unsafe { vtkMatrix3x3_new() }) } } impl std::default::Default for vtkMatrix3x3 { @@ -155,12 +1187,8 @@ impl Drop for vtkMatrix3x3 { #[test] fn test_vtkMatrix3x3_create_drop() { let obj = vtkMatrix3x3::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMatrix3x3(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// represent and manipulate 4x4 transformation matrices /// @@ -176,22 +1204,13 @@ fn test_vtkMatrix3x3_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMatrix4x4(*mut core::ffi::c_void); impl vtkMatrix4x4 { - /// Creates a new [vtkMatrix4x4] wrapped inside `vtkNew` + /// Creates a new [vtkMatrix4x4] via `vtkMatrix4x4::New()` #[doc(alias = "vtkMatrix4x4")] pub fn new() -> Self { unsafe extern "C" { fn vtkMatrix4x4_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMatrix4x4_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMatrix4x4_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMatrix4x4_get_ptr(self.0) } + Self(unsafe { vtkMatrix4x4_new() }) } } impl std::default::Default for vtkMatrix4x4 { @@ -211,12 +1230,8 @@ impl Drop for vtkMatrix4x4 { #[test] fn test_vtkMatrix4x4_create_drop() { let obj = vtkMatrix4x4::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMatrix4x4(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// polynomial solvers /// @@ -242,22 +1257,13 @@ fn test_vtkMatrix4x4_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPolynomialSolversUnivariate(*mut core::ffi::c_void); impl vtkPolynomialSolversUnivariate { - /// Creates a new [vtkPolynomialSolversUnivariate] wrapped inside `vtkNew` + /// Creates a new [vtkPolynomialSolversUnivariate] via `vtkPolynomialSolversUnivariate::New()` #[doc(alias = "vtkPolynomialSolversUnivariate")] pub fn new() -> Self { unsafe extern "C" { fn vtkPolynomialSolversUnivariate_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPolynomialSolversUnivariate_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPolynomialSolversUnivariate_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPolynomialSolversUnivariate_get_ptr(self.0) } + Self(unsafe { vtkPolynomialSolversUnivariate_new() }) } } impl std::default::Default for vtkPolynomialSolversUnivariate { @@ -277,12 +1283,8 @@ impl Drop for vtkPolynomialSolversUnivariate { #[test] fn test_vtkPolynomialSolversUnivariate_create_drop() { let obj = vtkPolynomialSolversUnivariate::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPolynomialSolversUnivariate(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// interpolate a quaternion /// @@ -324,22 +1326,13 @@ fn test_vtkPolynomialSolversUnivariate_create_drop() { #[allow(non_camel_case_types)] pub struct vtkQuaternionInterpolator(*mut core::ffi::c_void); impl vtkQuaternionInterpolator { - /// Creates a new [vtkQuaternionInterpolator] wrapped inside `vtkNew` + /// Creates a new [vtkQuaternionInterpolator] via `vtkQuaternionInterpolator::New()` #[doc(alias = "vtkQuaternionInterpolator")] pub fn new() -> Self { unsafe extern "C" { fn vtkQuaternionInterpolator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkQuaternionInterpolator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkQuaternionInterpolator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkQuaternionInterpolator_get_ptr(self.0) } + Self(unsafe { vtkQuaternionInterpolator_new() }) } } impl std::default::Default for vtkQuaternionInterpolator { @@ -359,12 +1352,8 @@ impl Drop for vtkQuaternionInterpolator { #[test] fn test_vtkQuaternionInterpolator_create_drop() { let obj = vtkQuaternionInterpolator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkQuaternionInterpolator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Integrate an initial value problem using 2nd /// @@ -380,22 +1369,13 @@ fn test_vtkQuaternionInterpolator_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRungeKutta2(*mut core::ffi::c_void); impl vtkRungeKutta2 { - /// Creates a new [vtkRungeKutta2] wrapped inside `vtkNew` + /// Creates a new [vtkRungeKutta2] via `vtkRungeKutta2::New()` #[doc(alias = "vtkRungeKutta2")] pub fn new() -> Self { unsafe extern "C" { fn vtkRungeKutta2_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRungeKutta2_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRungeKutta2_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRungeKutta2_get_ptr(self.0) } + Self(unsafe { vtkRungeKutta2_new() }) } } impl std::default::Default for vtkRungeKutta2 { @@ -415,12 +1395,8 @@ impl Drop for vtkRungeKutta2 { #[test] fn test_vtkRungeKutta2_create_drop() { let obj = vtkRungeKutta2::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRungeKutta2(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Integrate an initial value problem using 4th /// @@ -436,22 +1412,13 @@ fn test_vtkRungeKutta2_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRungeKutta4(*mut core::ffi::c_void); impl vtkRungeKutta4 { - /// Creates a new [vtkRungeKutta4] wrapped inside `vtkNew` + /// Creates a new [vtkRungeKutta4] via `vtkRungeKutta4::New()` #[doc(alias = "vtkRungeKutta4")] pub fn new() -> Self { unsafe extern "C" { fn vtkRungeKutta4_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRungeKutta4_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRungeKutta4_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRungeKutta4_get_ptr(self.0) } + Self(unsafe { vtkRungeKutta4_new() }) } } impl std::default::Default for vtkRungeKutta4 { @@ -471,12 +1438,8 @@ impl Drop for vtkRungeKutta4 { #[test] fn test_vtkRungeKutta4_create_drop() { let obj = vtkRungeKutta4::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRungeKutta4(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Integrate an initial value problem using 5th /// @@ -498,22 +1461,13 @@ fn test_vtkRungeKutta4_create_drop() { #[allow(non_camel_case_types)] pub struct vtkRungeKutta45(*mut core::ffi::c_void); impl vtkRungeKutta45 { - /// Creates a new [vtkRungeKutta45] wrapped inside `vtkNew` + /// Creates a new [vtkRungeKutta45] via `vtkRungeKutta45::New()` #[doc(alias = "vtkRungeKutta45")] pub fn new() -> Self { unsafe extern "C" { fn vtkRungeKutta45_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkRungeKutta45_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkRungeKutta45_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkRungeKutta45_get_ptr(self.0) } + Self(unsafe { vtkRungeKutta45_new() }) } } impl std::default::Default for vtkRungeKutta45 { @@ -533,10 +1487,6 @@ impl Drop for vtkRungeKutta45 { #[test] fn test_vtkRungeKutta45_create_drop() { let obj = vtkRungeKutta45::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkRungeKutta45(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonMisc.rs b/vtk-rs-9.1/src/vtkCommonMisc.rs index 639ff5f..e786c47 100644 --- a/vtk-rs-9.1/src/vtkCommonMisc.rs +++ b/vtk-rs-9.1/src/vtkCommonMisc.rs @@ -1,3 +1,942 @@ +pub trait VtkContourValues { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_value(&mut self, i: core::ffi::c_int, value: core::ffi::c_double) -> (); + fn get_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn set_number_of_contours(&mut self, number: core::ffi::c_int) -> (); + fn get_number_of_contours(&mut self) -> core::ffi::c_int; + fn generate_values( + &mut self, + numContours: core::ffi::c_int, + rangeStart: core::ffi::c_double, + rangeEnd: core::ffi::c_double, + ) -> (); + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> (); +} +pub trait VtkErrorCode { + fn get_string_from_error_code(&mut self, error: core::ffi::c_ulong) -> &str; + fn get_error_code_from_string(&mut self, error: &str) -> core::ffi::c_ulong; + fn get_last_system_error(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkExprTkFunctionParser { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_function(&mut self, function: &str) -> (); + fn get_function(&mut self) -> &str; + fn is_scalar_result(&mut self) -> core::ffi::c_int; + fn is_vector_result(&mut self) -> core::ffi::c_int; + fn get_scalar_result(&mut self) -> core::ffi::c_double; + fn set_scalar_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> (); + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double; + fn set_vector_variable_value( + &mut self, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> (); + fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int; + fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int; + fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool; + fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool; + fn remove_all_variables(&mut self) -> (); + fn remove_scalar_variables(&mut self) -> (); + fn remove_vector_variables(&mut self) -> (); + fn set_replace_invalid_values(&mut self, _arg: core::ffi::c_int) -> (); + fn get_replace_invalid_values(&mut self) -> core::ffi::c_int; + fn replace_invalid_values_on(&mut self) -> (); + fn replace_invalid_values_off(&mut self) -> (); + fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_replacement_value(&mut self) -> core::ffi::c_double; + fn invalidate_function(&mut self) -> (); +} +pub trait VtkFunctionParser { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_function(&mut self, function: &str) -> (); + fn is_scalar_result(&mut self) -> core::ffi::c_int; + fn is_vector_result(&mut self) -> core::ffi::c_int; + fn get_scalar_result(&mut self) -> core::ffi::c_double; + fn set_scalar_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> (); + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double; + fn set_vector_variable_value( + &mut self, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> (); + fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int; + fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int; + fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int; + fn get_scalar_variable_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_vector_variable_name(&mut self, i: core::ffi::c_int) -> &str; + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool; + fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool; + fn remove_all_variables(&mut self) -> (); + fn remove_scalar_variables(&mut self) -> (); + fn remove_vector_variables(&mut self) -> (); + fn set_replace_invalid_values(&mut self, _arg: core::ffi::c_int) -> (); + fn get_replace_invalid_values(&mut self) -> core::ffi::c_int; + fn replace_invalid_values_on(&mut self) -> (); + fn replace_invalid_values_off(&mut self) -> (); + fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> (); + fn get_replacement_value(&mut self) -> core::ffi::c_double; + fn invalidate_function(&mut self) -> (); +} +pub trait VtkHeap { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_block_size(&mut self, p0: usize) -> (); + fn get_block_size(&mut self) -> usize; + fn get_number_of_blocks(&mut self) -> core::ffi::c_int; + fn get_number_of_allocations(&mut self) -> core::ffi::c_int; + fn reset(&mut self) -> (); +} +pub trait VtkPolygonBuilder { + fn get_polygons(&mut self, polys: *mut core::ffi::c_void) -> (); + fn reset(&mut self) -> (); +} +pub trait VtkResourceFileLocator { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_print_debug_information(&mut self, p0: bool) -> (); + fn get_print_debug_information(&mut self) -> bool; + fn print_debug_information_on(&mut self) -> (); + fn print_debug_information_off(&mut self) -> (); + fn set_log_verbosity(&mut self, _arg: core::ffi::c_int) -> (); + fn get_log_verbosity(&mut self) -> core::ffi::c_int; +} +impl VtkContourValues for vtkContourValues { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_contour_values_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_contour_values_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_contour_values_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_contour_values_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_contour_values_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_contour_values_new_instance(self.0) } + } + fn set_value(&mut self, i: core::ffi::c_int, value: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_contour_values_set_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_contour_values_set_value(self.0, i, value) } + } + fn get_value(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_contour_values_get_value( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_contour_values_get_value(self.0, i) } + } + fn set_number_of_contours(&mut self, number: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_contour_values_set_number_of_contours( + sself: *mut core::ffi::c_void, + number: core::ffi::c_int, + ); + } + unsafe { vtk_contour_values_set_number_of_contours(self.0, number) } + } + fn get_number_of_contours(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_contour_values_get_number_of_contours( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_contour_values_get_number_of_contours(self.0) } + } + fn generate_values( + &mut self, + numContours: core::ffi::c_int, + rangeStart: core::ffi::c_double, + rangeEnd: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_contour_values_generate_values( + sself: *mut core::ffi::c_void, + numContours: core::ffi::c_int, + rangeStart: core::ffi::c_double, + rangeEnd: core::ffi::c_double, + ); + } + unsafe { + vtk_contour_values_generate_values(self.0, numContours, rangeStart, rangeEnd) + } + } + fn deep_copy(&mut self, other: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_contour_values_deep_copy( + sself: *mut core::ffi::c_void, + other: *mut core::ffi::c_void, + ); + } + unsafe { vtk_contour_values_deep_copy(self.0, other) } + } +} +impl VtkExprTkFunctionParser for vtkExprTkFunctionParser { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_expr_tk_function_parser_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_expr_tk_function_parser_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_expr_tk_function_parser_new_instance(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_expr_tk_function_parser_get_m_time(self.0) } + } + fn set_function(&mut self, function: &str) -> () { + let c_function = std::ffi::CString::new(function).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_function( + sself: *mut core::ffi::c_void, + function: *const core::ffi::c_char, + ); + } + unsafe { vtk_expr_tk_function_parser_set_function(self.0, c_function.as_ptr()) } + } + fn get_function(&mut self) -> &str { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_function( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_expr_tk_function_parser_get_function(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn is_scalar_result(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_is_scalar_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_is_scalar_result(self.0) } + } + fn is_vector_result(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_is_vector_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_is_vector_result(self.0) } + } + fn get_scalar_result(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_expr_tk_function_parser_get_scalar_result(self.0) } + } + fn set_scalar_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_set_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + value, + ) + } + } + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { + vtk_expr_tk_function_parser_get_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn set_vector_variable_value( + &mut self, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ); + } + unsafe { + vtk_expr_tk_function_parser_set_vector_variable_value( + self.0, + c_variableName.as_ptr(), + xValue, + yValue, + zValue, + ) + } + } + fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_number_of_scalar_variables( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_get_number_of_scalar_variables(self.0) } + } + fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_expr_tk_function_parser_get_scalar_variable_index( + self.0, + c_name.as_ptr(), + ) + } + } + fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_number_of_vector_variables( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_get_number_of_vector_variables(self.0) } + } + fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { + vtk_expr_tk_function_parser_get_vector_variable_index( + self.0, + c_name.as_ptr(), + ) + } + } + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_scalar_variable_needed( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_expr_tk_function_parser_get_scalar_variable_needed(self.0, i) } + } + fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_vector_variable_needed( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_expr_tk_function_parser_get_vector_variable_needed(self.0, i) } + } + fn remove_all_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_remove_all_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_remove_all_variables(self.0) } + } + fn remove_scalar_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_remove_scalar_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_remove_scalar_variables(self.0) } + } + fn remove_vector_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_remove_vector_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_remove_vector_variables(self.0) } + } + fn set_replace_invalid_values(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_replace_invalid_values( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_expr_tk_function_parser_set_replace_invalid_values(self.0, _arg) } + } + fn get_replace_invalid_values(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_replace_invalid_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_expr_tk_function_parser_get_replace_invalid_values(self.0) } + } + fn replace_invalid_values_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_replace_invalid_values_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_replace_invalid_values_on(self.0) } + } + fn replace_invalid_values_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_replace_invalid_values_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_replace_invalid_values_off(self.0) } + } + fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_set_replacement_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_expr_tk_function_parser_set_replacement_value(self.0, _arg) } + } + fn get_replacement_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_get_replacement_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_expr_tk_function_parser_get_replacement_value(self.0) } + } + fn invalidate_function(&mut self) -> () { + unsafe extern "C" { + fn vtk_expr_tk_function_parser_invalidate_function( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_expr_tk_function_parser_invalidate_function(self.0) } + } +} +impl VtkFunctionParser for vtkFunctionParser { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_function_parser_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_function_parser_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_function_parser_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_function_parser_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_function_parser_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_function_parser_new_instance(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_function_parser_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_function_parser_get_m_time(self.0) } + } + fn set_function(&mut self, function: &str) -> () { + let c_function = std::ffi::CString::new(function).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_set_function( + sself: *mut core::ffi::c_void, + function: *const core::ffi::c_char, + ); + } + unsafe { vtk_function_parser_set_function(self.0, c_function.as_ptr()) } + } + fn is_scalar_result(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_is_scalar_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_is_scalar_result(self.0) } + } + fn is_vector_result(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_is_vector_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_is_vector_result(self.0) } + } + fn get_scalar_result(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_result( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_function_parser_get_scalar_result(self.0) } + } + fn set_scalar_variable_value( + &mut self, + variableName: &str, + value: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_set_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + value: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + value, + ) + } + } + fn get_scalar_variable_value(&mut self, variableName: &str) -> core::ffi::c_double { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + ) -> core::ffi::c_double; + } + unsafe { + vtk_function_parser_get_scalar_variable_value( + self.0, + c_variableName.as_ptr(), + ) + } + } + fn set_vector_variable_value( + &mut self, + variableName: &str, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ) -> () { + let c_variableName = std::ffi::CString::new(variableName) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_set_vector_variable_value( + sself: *mut core::ffi::c_void, + variableName: *const core::ffi::c_char, + xValue: core::ffi::c_double, + yValue: core::ffi::c_double, + zValue: core::ffi::c_double, + ); + } + unsafe { + vtk_function_parser_set_vector_variable_value( + self.0, + c_variableName.as_ptr(), + xValue, + yValue, + zValue, + ) + } + } + fn get_number_of_scalar_variables(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_get_number_of_scalar_variables( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_number_of_scalar_variables(self.0) } + } + fn get_scalar_variable_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_scalar_variable_index(self.0, c_name.as_ptr()) } + } + fn get_number_of_vector_variables(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_get_number_of_vector_variables( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_number_of_vector_variables(self.0) } + } + fn get_vector_variable_index(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_index( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_vector_variable_index(self.0, c_name.as_ptr()) } + } + fn get_scalar_variable_name(&mut self, i: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_function_parser_get_scalar_variable_name(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_vector_variable_name(&mut self, i: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_name( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_function_parser_get_vector_variable_name(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_scalar_variable_needed(&mut self, i: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_function_parser_get_scalar_variable_needed( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_function_parser_get_scalar_variable_needed(self.0, i) } + } + fn get_vector_variable_needed(&mut self, i: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_function_parser_get_vector_variable_needed( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_function_parser_get_vector_variable_needed(self.0, i) } + } + fn remove_all_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_remove_all_variables(sself: *mut core::ffi::c_void); + } + unsafe { vtk_function_parser_remove_all_variables(self.0) } + } + fn remove_scalar_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_remove_scalar_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_function_parser_remove_scalar_variables(self.0) } + } + fn remove_vector_variables(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_remove_vector_variables( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_function_parser_remove_vector_variables(self.0) } + } + fn set_replace_invalid_values(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_replace_invalid_values( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_function_parser_set_replace_invalid_values(self.0, _arg) } + } + fn get_replace_invalid_values(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_function_parser_get_replace_invalid_values( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_function_parser_get_replace_invalid_values(self.0) } + } + fn replace_invalid_values_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_replace_invalid_values_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_function_parser_replace_invalid_values_on(self.0) } + } + fn replace_invalid_values_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_replace_invalid_values_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_function_parser_replace_invalid_values_off(self.0) } + } + fn set_replacement_value(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_function_parser_set_replacement_value( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_function_parser_set_replacement_value(self.0, _arg) } + } + fn get_replacement_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_function_parser_get_replacement_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_function_parser_get_replacement_value(self.0) } + } + fn invalidate_function(&mut self) -> () { + unsafe extern "C" { + fn vtk_function_parser_invalidate_function(sself: *mut core::ffi::c_void); + } + unsafe { vtk_function_parser_invalidate_function(self.0) } + } +} +impl VtkHeap for vtkHeap { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_heap_new(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + } + unsafe { vtk_heap_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_heap_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_heap_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_heap_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_heap_new_instance(self.0) } + } + fn set_block_size(&mut self, p0: usize) -> () { + unsafe extern "C" { + fn vtk_heap_set_block_size(sself: *mut core::ffi::c_void, p0: usize); + } + unsafe { vtk_heap_set_block_size(self.0, p0) } + } + fn get_block_size(&mut self) -> usize { + unsafe extern "C" { + fn vtk_heap_get_block_size(sself: *mut core::ffi::c_void) -> usize; + } + unsafe { vtk_heap_get_block_size(self.0) } + } + fn get_number_of_blocks(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_heap_get_number_of_blocks( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_heap_get_number_of_blocks(self.0) } + } + fn get_number_of_allocations(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_heap_get_number_of_allocations( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_heap_get_number_of_allocations(self.0) } + } + fn reset(&mut self) -> () { + unsafe extern "C" { + fn vtk_heap_reset(sself: *mut core::ffi::c_void); + } + unsafe { vtk_heap_reset(self.0) } + } +} +impl VtkResourceFileLocator for vtkResourceFileLocator { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_resource_file_locator_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_resource_file_locator_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_resource_file_locator_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_resource_file_locator_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_resource_file_locator_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_resource_file_locator_new_instance(self.0) } + } + fn set_print_debug_information(&mut self, p0: bool) -> () { + unsafe extern "C" { + fn vtk_resource_file_locator_set_print_debug_information( + sself: *mut core::ffi::c_void, + p0: bool, + ); + } + unsafe { vtk_resource_file_locator_set_print_debug_information(self.0, p0) } + } + fn get_print_debug_information(&mut self) -> bool { + unsafe extern "C" { + fn vtk_resource_file_locator_get_print_debug_information( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_resource_file_locator_get_print_debug_information(self.0) } + } + fn print_debug_information_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_resource_file_locator_print_debug_information_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_resource_file_locator_print_debug_information_on(self.0) } + } + fn print_debug_information_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_resource_file_locator_print_debug_information_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_resource_file_locator_print_debug_information_off(self.0) } + } + fn set_log_verbosity(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_resource_file_locator_set_log_verbosity( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_resource_file_locator_set_log_verbosity(self.0, _arg) } + } + fn get_log_verbosity(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_resource_file_locator_get_log_verbosity( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_resource_file_locator_get_log_verbosity(self.0) } + } +} /// helper object to manage setting and generating contour values /// /// @@ -10,22 +949,13 @@ #[allow(non_camel_case_types)] pub struct vtkContourValues(*mut core::ffi::c_void); impl vtkContourValues { - /// Creates a new [vtkContourValues] wrapped inside `vtkNew` + /// Creates a new [vtkContourValues] via `vtkContourValues::New()` #[doc(alias = "vtkContourValues")] pub fn new() -> Self { unsafe extern "C" { fn vtkContourValues_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkContourValues_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkContourValues_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkContourValues_get_ptr(self.0) } + Self(unsafe { vtkContourValues_new() }) } } impl std::default::Default for vtkContourValues { @@ -45,12 +975,8 @@ impl Drop for vtkContourValues { #[test] fn test_vtkContourValues_create_drop() { let obj = vtkContourValues::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkContourValues(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Parse and evaluate a mathematical expression /// @@ -71,22 +997,13 @@ fn test_vtkContourValues_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExprTkFunctionParser(*mut core::ffi::c_void); impl vtkExprTkFunctionParser { - /// Creates a new [vtkExprTkFunctionParser] wrapped inside `vtkNew` + /// Creates a new [vtkExprTkFunctionParser] via `vtkExprTkFunctionParser::New()` #[doc(alias = "vtkExprTkFunctionParser")] pub fn new() -> Self { unsafe extern "C" { fn vtkExprTkFunctionParser_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExprTkFunctionParser_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExprTkFunctionParser_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExprTkFunctionParser_get_ptr(self.0) } + Self(unsafe { vtkExprTkFunctionParser_new() }) } } impl std::default::Default for vtkExprTkFunctionParser { @@ -106,12 +1023,8 @@ impl Drop for vtkExprTkFunctionParser { #[test] fn test_vtkExprTkFunctionParser_create_drop() { let obj = vtkExprTkFunctionParser::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExprTkFunctionParser(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Parse and evaluate a mathematical expression /// @@ -144,22 +1057,13 @@ fn test_vtkExprTkFunctionParser_create_drop() { #[allow(non_camel_case_types)] pub struct vtkFunctionParser(*mut core::ffi::c_void); impl vtkFunctionParser { - /// Creates a new [vtkFunctionParser] wrapped inside `vtkNew` + /// Creates a new [vtkFunctionParser] via `vtkFunctionParser::New()` #[doc(alias = "vtkFunctionParser")] pub fn new() -> Self { unsafe extern "C" { fn vtkFunctionParser_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkFunctionParser_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkFunctionParser_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkFunctionParser_get_ptr(self.0) } + Self(unsafe { vtkFunctionParser_new() }) } } impl std::default::Default for vtkFunctionParser { @@ -179,12 +1083,8 @@ impl Drop for vtkFunctionParser { #[test] fn test_vtkFunctionParser_create_drop() { let obj = vtkFunctionParser::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkFunctionParser(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// replacement for malloc/free and new/delete /// @@ -216,20 +1116,13 @@ fn test_vtkFunctionParser_create_drop() { #[allow(non_camel_case_types)] pub struct vtkHeap(*mut core::ffi::c_void); impl vtkHeap { - /// Creates a new [vtkHeap] wrapped inside `vtkNew` + /// Creates a new [vtkHeap] via `vtkHeap::New()` #[doc(alias = "vtkHeap")] pub fn new() -> Self { unsafe extern "C" { fn vtkHeap_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkHeap_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkHeap_get_ptr(sself: *mut core::ffi::c_void) -> *mut core::ffi::c_void; - } - unsafe { vtkHeap_get_ptr(self.0) } + Self(unsafe { vtkHeap_new() }) } } impl std::default::Default for vtkHeap { @@ -249,12 +1142,8 @@ impl Drop for vtkHeap { #[test] fn test_vtkHeap_create_drop() { let obj = vtkHeap::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkHeap(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// utility to locate resource files. /// @@ -273,22 +1162,13 @@ fn test_vtkHeap_create_drop() { #[allow(non_camel_case_types)] pub struct vtkResourceFileLocator(*mut core::ffi::c_void); impl vtkResourceFileLocator { - /// Creates a new [vtkResourceFileLocator] wrapped inside `vtkNew` + /// Creates a new [vtkResourceFileLocator] via `vtkResourceFileLocator::New()` #[doc(alias = "vtkResourceFileLocator")] pub fn new() -> Self { unsafe extern "C" { fn vtkResourceFileLocator_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkResourceFileLocator_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkResourceFileLocator_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkResourceFileLocator_get_ptr(self.0) } + Self(unsafe { vtkResourceFileLocator_new() }) } } impl std::default::Default for vtkResourceFileLocator { @@ -308,10 +1188,6 @@ impl Drop for vtkResourceFileLocator { #[test] fn test_vtkResourceFileLocator_create_drop() { let obj = vtkResourceFileLocator::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkResourceFileLocator(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonSystem.rs b/vtk-rs-9.1/src/vtkCommonSystem.rs index b14eeba..cd10a48 100644 --- a/vtk-rs-9.1/src/vtkCommonSystem.rs +++ b/vtk-rs-9.1/src/vtkCommonSystem.rs @@ -1,24 +1,826 @@ +pub trait VtkClientSocket { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn connect_to_server( + &mut self, + hostname: &str, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + fn get_connecting_side(&mut self) -> bool; +} +pub trait VtkDirectory { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn open(&mut self, dir: &str) -> core::ffi::c_int; + fn get_number_of_files(&mut self) -> core::ffi::c_longlong; + fn get_file(&mut self, index: core::ffi::c_longlong) -> &str; + fn file_is_directory(&mut self, name: &str) -> core::ffi::c_int; + fn get_files(&mut self) -> *mut core::ffi::c_void; + fn make_directory(&mut self, dir: &str) -> core::ffi::c_int; + fn delete_directory(&mut self, dir: &str) -> core::ffi::c_int; + fn rename(&mut self, oldname: &str, newname: &str) -> core::ffi::c_int; +} +pub trait VtkExecutableRunner { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn execute(&mut self) -> (); + fn set_timeout(&mut self, _arg: core::ffi::c_double) -> (); + fn get_timeout(&mut self) -> core::ffi::c_double; + fn set_right_trim_result(&mut self, _arg: bool) -> (); + fn get_right_trim_result(&mut self) -> bool; + fn right_trim_result_on(&mut self) -> (); + fn right_trim_result_off(&mut self) -> (); + fn get_command(&mut self) -> &str; + fn set_command(&mut self, arg: &str) -> (); + fn get_std_out(&mut self) -> &str; + fn get_std_err(&mut self) -> &str; + fn get_return_value(&mut self) -> core::ffi::c_int; +} +pub trait VtkServerSocket { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn create_server(&mut self, port: core::ffi::c_int) -> core::ffi::c_int; + fn wait_for_connection( + &mut self, + msec: core::ffi::c_ulong, + ) -> *mut core::ffi::c_void; + fn get_server_port(&mut self) -> core::ffi::c_int; +} +pub trait VtkSocket { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_connected(&mut self) -> core::ffi::c_int; + fn close_socket(&mut self) -> (); + fn get_socket_descriptor(&mut self) -> core::ffi::c_int; +} +pub trait VtkSocketCollection { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, soc: *mut core::ffi::c_void) -> (); + fn select_sockets(&mut self, msec: core::ffi::c_ulong) -> core::ffi::c_int; + fn get_last_selected_socket(&mut self) -> *mut core::ffi::c_void; + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> (); +} +pub trait VtkThreadMessager { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn wait_for_message(&mut self) -> (); + fn send_wake_message(&mut self) -> (); + fn enable_wait_for_receiver(&mut self) -> (); + fn disable_wait_for_receiver(&mut self) -> (); + fn wait_for_receiver(&mut self) -> (); +} +pub trait VtkTimerLog { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_logging(&mut self, v: core::ffi::c_int) -> (); + fn get_logging(&mut self) -> core::ffi::c_int; + fn logging_on(&mut self) -> (); + fn logging_off(&mut self) -> (); + fn set_max_entries(&mut self, a: core::ffi::c_int) -> (); + fn get_max_entries(&mut self) -> core::ffi::c_int; + fn dump_log(&mut self, filename: &str) -> (); + fn mark_start_event(&mut self, EventString: &str) -> (); + fn mark_end_event(&mut self, EventString: &str) -> (); + fn insert_timed_event( + &mut self, + EventString: &str, + time: core::ffi::c_double, + cpuTicks: core::ffi::c_int, + ) -> (); + fn get_number_of_events(&mut self) -> core::ffi::c_int; + fn get_event_indent(&mut self, i: core::ffi::c_int) -> core::ffi::c_int; + fn get_event_wall_time(&mut self, i: core::ffi::c_int) -> core::ffi::c_double; + fn get_event_string(&mut self, i: core::ffi::c_int) -> &str; + fn mark_event(&mut self, EventString: &str) -> (); + fn reset_log(&mut self) -> (); + fn cleanup_log(&mut self) -> (); + fn get_universal_time(&mut self) -> core::ffi::c_double; + fn get_cpu_time(&mut self) -> core::ffi::c_double; + fn start_timer(&mut self) -> (); + fn stop_timer(&mut self) -> (); + fn get_elapsed_time(&mut self) -> core::ffi::c_double; +} +impl VtkClientSocket for vtkClientSocket { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_client_socket_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_client_socket_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_client_socket_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_client_socket_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_client_socket_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_client_socket_new_instance(self.0) } + } + fn connect_to_server( + &mut self, + hostname: &str, + port: core::ffi::c_int, + ) -> core::ffi::c_int { + let c_hostname = std::ffi::CString::new(hostname).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_client_socket_connect_to_server( + sself: *mut core::ffi::c_void, + hostname: *const core::ffi::c_char, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_client_socket_connect_to_server(self.0, c_hostname.as_ptr(), port) } + } + fn get_connecting_side(&mut self) -> bool { + unsafe extern "C" { + fn vtk_client_socket_get_connecting_side( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_client_socket_get_connecting_side(self.0) } + } +} +impl VtkDirectory for vtkDirectory { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directory_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directory_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directory_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directory_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directory_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directory_new(self.0) } + } + fn open(&mut self, dir: &str) -> core::ffi::c_int { + let c_dir = std::ffi::CString::new(dir).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_directory_open( + sself: *mut core::ffi::c_void, + dir: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_open(self.0, c_dir.as_ptr()) } + } + fn get_number_of_files(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_directory_get_number_of_files( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_directory_get_number_of_files(self.0) } + } + fn get_file(&mut self, index: core::ffi::c_longlong) -> &str { + unsafe extern "C" { + fn vtk_directory_get_file( + sself: *mut core::ffi::c_void, + index: core::ffi::c_longlong, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_directory_get_file(self.0, index) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn file_is_directory(&mut self, name: &str) -> core::ffi::c_int { + let c_name = std::ffi::CString::new(name).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_directory_file_is_directory( + sself: *mut core::ffi::c_void, + name: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_file_is_directory(self.0, c_name.as_ptr()) } + } + fn get_files(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_directory_get_files( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_directory_get_files(self.0) } + } + fn make_directory(&mut self, dir: &str) -> core::ffi::c_int { + let c_dir = std::ffi::CString::new(dir).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_directory_make_directory( + sself: *mut core::ffi::c_void, + dir: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_make_directory(self.0, c_dir.as_ptr()) } + } + fn delete_directory(&mut self, dir: &str) -> core::ffi::c_int { + let c_dir = std::ffi::CString::new(dir).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_directory_delete_directory( + sself: *mut core::ffi::c_void, + dir: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_delete_directory(self.0, c_dir.as_ptr()) } + } + fn rename(&mut self, oldname: &str, newname: &str) -> core::ffi::c_int { + let c_oldname = std::ffi::CString::new(oldname).expect("CString::new failed"); + let c_newname = std::ffi::CString::new(newname).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_directory_rename( + sself: *mut core::ffi::c_void, + oldname: *const core::ffi::c_char, + newname: *const core::ffi::c_char, + ) -> core::ffi::c_int; + } + unsafe { vtk_directory_rename(self.0, c_oldname.as_ptr(), c_newname.as_ptr()) } + } +} +impl VtkExecutableRunner for vtkExecutableRunner { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_executable_runner_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_executable_runner_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_executable_runner_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_executable_runner_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_executable_runner_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_executable_runner_new_instance(self.0) } + } + fn execute(&mut self) -> () { + unsafe extern "C" { + fn vtk_executable_runner_execute(sself: *mut core::ffi::c_void); + } + unsafe { vtk_executable_runner_execute(self.0) } + } + fn set_timeout(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_executable_runner_set_timeout( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_executable_runner_set_timeout(self.0, _arg) } + } + fn get_timeout(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_executable_runner_get_timeout( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_executable_runner_get_timeout(self.0) } + } + fn set_right_trim_result(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_executable_runner_set_right_trim_result( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_executable_runner_set_right_trim_result(self.0, _arg) } + } + fn get_right_trim_result(&mut self) -> bool { + unsafe extern "C" { + fn vtk_executable_runner_get_right_trim_result( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_executable_runner_get_right_trim_result(self.0) } + } + fn right_trim_result_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_executable_runner_right_trim_result_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_executable_runner_right_trim_result_on(self.0) } + } + fn right_trim_result_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_executable_runner_right_trim_result_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_executable_runner_right_trim_result_off(self.0) } + } + fn get_command(&mut self) -> &str { + unsafe extern "C" { + fn vtk_executable_runner_get_command( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_executable_runner_get_command(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_command(&mut self, arg: &str) -> () { + let c_arg = std::ffi::CString::new(arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_executable_runner_set_command( + sself: *mut core::ffi::c_void, + arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_executable_runner_set_command(self.0, c_arg.as_ptr()) } + } + fn get_std_out(&mut self) -> &str { + unsafe extern "C" { + fn vtk_executable_runner_get_std_out( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_executable_runner_get_std_out(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_std_err(&mut self) -> &str { + unsafe extern "C" { + fn vtk_executable_runner_get_std_err( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_executable_runner_get_std_err(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn get_return_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_executable_runner_get_return_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_executable_runner_get_return_value(self.0) } + } +} +impl VtkServerSocket for vtkServerSocket { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_server_socket_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_server_socket_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_server_socket_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_server_socket_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_server_socket_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_server_socket_new_instance(self.0) } + } + fn create_server(&mut self, port: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_server_socket_create_server( + sself: *mut core::ffi::c_void, + port: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_server_socket_create_server(self.0, port) } + } + fn wait_for_connection( + &mut self, + msec: core::ffi::c_ulong, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_server_socket_wait_for_connection( + sself: *mut core::ffi::c_void, + msec: core::ffi::c_ulong, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_server_socket_wait_for_connection(self.0, msec) } + } + fn get_server_port(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_server_socket_get_server_port( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_server_socket_get_server_port(self.0) } + } +} +impl VtkSocketCollection for vtkSocketCollection { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_socket_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_socket_collection_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_socket_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_socket_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_socket_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_socket_collection_new_instance(self.0) } + } + fn add_item(&mut self, soc: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_socket_collection_add_item( + sself: *mut core::ffi::c_void, + soc: *mut core::ffi::c_void, + ); + } + unsafe { vtk_socket_collection_add_item(self.0, soc) } + } + fn select_sockets(&mut self, msec: core::ffi::c_ulong) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_socket_collection_select_sockets( + sself: *mut core::ffi::c_void, + msec: core::ffi::c_ulong, + ) -> core::ffi::c_int; + } + unsafe { vtk_socket_collection_select_sockets(self.0, msec) } + } + fn get_last_selected_socket(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_socket_collection_get_last_selected_socket( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_socket_collection_get_last_selected_socket(self.0) } + } + fn replace_item(&mut self, i: core::ffi::c_int, p1: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_socket_collection_replace_item( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + p1: *mut core::ffi::c_void, + ); + } + unsafe { vtk_socket_collection_replace_item(self.0, i, p1) } + } +} +impl VtkThreadMessager for vtkThreadMessager { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thread_messager_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thread_messager_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thread_messager_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thread_messager_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thread_messager_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thread_messager_new_instance(self.0) } + } + fn wait_for_message(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_wait_for_message(sself: *mut core::ffi::c_void); + } + unsafe { vtk_thread_messager_wait_for_message(self.0) } + } + fn send_wake_message(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_send_wake_message(sself: *mut core::ffi::c_void); + } + unsafe { vtk_thread_messager_send_wake_message(self.0) } + } + fn enable_wait_for_receiver(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_enable_wait_for_receiver( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thread_messager_enable_wait_for_receiver(self.0) } + } + fn disable_wait_for_receiver(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_disable_wait_for_receiver( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thread_messager_disable_wait_for_receiver(self.0) } + } + fn wait_for_receiver(&mut self) -> () { + unsafe extern "C" { + fn vtk_thread_messager_wait_for_receiver(sself: *mut core::ffi::c_void); + } + unsafe { vtk_thread_messager_wait_for_receiver(self.0) } + } +} +impl VtkTimerLog for vtkTimerLog { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_timer_log_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_timer_log_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_timer_log_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_timer_log_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_timer_log_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_timer_log_new_instance(self.0) } + } + fn set_logging(&mut self, v: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_timer_log_set_logging( + sself: *mut core::ffi::c_void, + v: core::ffi::c_int, + ); + } + unsafe { vtk_timer_log_set_logging(self.0, v) } + } + fn get_logging(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_timer_log_get_logging( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_timer_log_get_logging(self.0) } + } + fn logging_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_logging_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_logging_on(self.0) } + } + fn logging_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_logging_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_logging_off(self.0) } + } + fn set_max_entries(&mut self, a: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_timer_log_set_max_entries( + sself: *mut core::ffi::c_void, + a: core::ffi::c_int, + ); + } + unsafe { vtk_timer_log_set_max_entries(self.0, a) } + } + fn get_max_entries(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_timer_log_get_max_entries( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_timer_log_get_max_entries(self.0) } + } + fn dump_log(&mut self, filename: &str) -> () { + let c_filename = std::ffi::CString::new(filename).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_timer_log_dump_log( + sself: *mut core::ffi::c_void, + filename: *const core::ffi::c_char, + ); + } + unsafe { vtk_timer_log_dump_log(self.0, c_filename.as_ptr()) } + } + fn mark_start_event(&mut self, EventString: &str) -> () { + let c_EventString = std::ffi::CString::new(EventString) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_timer_log_mark_start_event( + sself: *mut core::ffi::c_void, + EventString: *const core::ffi::c_char, + ); + } + unsafe { vtk_timer_log_mark_start_event(self.0, c_EventString.as_ptr()) } + } + fn mark_end_event(&mut self, EventString: &str) -> () { + let c_EventString = std::ffi::CString::new(EventString) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_timer_log_mark_end_event( + sself: *mut core::ffi::c_void, + EventString: *const core::ffi::c_char, + ); + } + unsafe { vtk_timer_log_mark_end_event(self.0, c_EventString.as_ptr()) } + } + fn insert_timed_event( + &mut self, + EventString: &str, + time: core::ffi::c_double, + cpuTicks: core::ffi::c_int, + ) -> () { + let c_EventString = std::ffi::CString::new(EventString) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_timer_log_insert_timed_event( + sself: *mut core::ffi::c_void, + EventString: *const core::ffi::c_char, + time: core::ffi::c_double, + cpuTicks: core::ffi::c_int, + ); + } + unsafe { + vtk_timer_log_insert_timed_event( + self.0, + c_EventString.as_ptr(), + time, + cpuTicks, + ) + } + } + fn get_number_of_events(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_timer_log_get_number_of_events( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_timer_log_get_number_of_events(self.0) } + } + fn get_event_indent(&mut self, i: core::ffi::c_int) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_timer_log_get_event_indent( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_int; + } + unsafe { vtk_timer_log_get_event_indent(self.0, i) } + } + fn get_event_wall_time(&mut self, i: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_timer_log_get_event_wall_time( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_timer_log_get_event_wall_time(self.0, i) } + } + fn get_event_string(&mut self, i: core::ffi::c_int) -> &str { + unsafe extern "C" { + fn vtk_timer_log_get_event_string( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_timer_log_get_event_string(self.0, i) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn mark_event(&mut self, EventString: &str) -> () { + let c_EventString = std::ffi::CString::new(EventString) + .expect("CString::new failed"); + unsafe extern "C" { + fn vtk_timer_log_mark_event( + sself: *mut core::ffi::c_void, + EventString: *const core::ffi::c_char, + ); + } + unsafe { vtk_timer_log_mark_event(self.0, c_EventString.as_ptr()) } + } + fn reset_log(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_reset_log(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_reset_log(self.0) } + } + fn cleanup_log(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_cleanup_log(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_cleanup_log(self.0) } + } + fn get_universal_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_timer_log_get_universal_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_timer_log_get_universal_time(self.0) } + } + fn get_cpu_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_timer_log_get_cpu_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_timer_log_get_cpu_time(self.0) } + } + fn start_timer(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_start_timer(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_start_timer(self.0) } + } + fn stop_timer(&mut self) -> () { + unsafe extern "C" { + fn vtk_timer_log_stop_timer(sself: *mut core::ffi::c_void); + } + unsafe { vtk_timer_log_stop_timer(self.0) } + } + fn get_elapsed_time(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_timer_log_get_elapsed_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_timer_log_get_elapsed_time(self.0) } + } +} /// Encapsulates a client socket. /// #[allow(non_camel_case_types)] pub struct vtkClientSocket(*mut core::ffi::c_void); impl vtkClientSocket { - /// Creates a new [vtkClientSocket] wrapped inside `vtkNew` + /// Creates a new [vtkClientSocket] via `vtkClientSocket::New()` #[doc(alias = "vtkClientSocket")] pub fn new() -> Self { unsafe extern "C" { fn vtkClientSocket_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkClientSocket_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkClientSocket_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkClientSocket_get_ptr(self.0) } + Self(unsafe { vtkClientSocket_new() }) } } impl std::default::Default for vtkClientSocket { @@ -38,12 +840,8 @@ impl Drop for vtkClientSocket { #[test] fn test_vtkClientSocket_create_drop() { let obj = vtkClientSocket::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkClientSocket(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// OS independent class for access and manipulation of system directories /// @@ -56,22 +854,13 @@ fn test_vtkClientSocket_create_drop() { #[allow(non_camel_case_types)] pub struct vtkDirectory(*mut core::ffi::c_void); impl vtkDirectory { - /// Creates a new [vtkDirectory] wrapped inside `vtkNew` + /// Creates a new [vtkDirectory] via `vtkDirectory::New()` #[doc(alias = "vtkDirectory")] pub fn new() -> Self { unsafe extern "C" { fn vtkDirectory_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkDirectory_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkDirectory_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkDirectory_get_ptr(self.0) } + Self(unsafe { vtkDirectory_new() }) } } impl std::default::Default for vtkDirectory { @@ -91,12 +880,8 @@ impl Drop for vtkDirectory { #[test] fn test_vtkDirectory_create_drop() { let obj = vtkDirectory::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkDirectory(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Launch a process on the current machine and get its output /// @@ -106,22 +891,13 @@ fn test_vtkDirectory_create_drop() { #[allow(non_camel_case_types)] pub struct vtkExecutableRunner(*mut core::ffi::c_void); impl vtkExecutableRunner { - /// Creates a new [vtkExecutableRunner] wrapped inside `vtkNew` + /// Creates a new [vtkExecutableRunner] via `vtkExecutableRunner::New()` #[doc(alias = "vtkExecutableRunner")] pub fn new() -> Self { unsafe extern "C" { fn vtkExecutableRunner_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkExecutableRunner_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkExecutableRunner_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkExecutableRunner_get_ptr(self.0) } + Self(unsafe { vtkExecutableRunner_new() }) } } impl std::default::Default for vtkExecutableRunner { @@ -141,34 +917,21 @@ impl Drop for vtkExecutableRunner { #[test] fn test_vtkExecutableRunner_create_drop() { let obj = vtkExecutableRunner::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkExecutableRunner(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Encapsulate a socket that accepts connections. /// #[allow(non_camel_case_types)] pub struct vtkServerSocket(*mut core::ffi::c_void); impl vtkServerSocket { - /// Creates a new [vtkServerSocket] wrapped inside `vtkNew` + /// Creates a new [vtkServerSocket] via `vtkServerSocket::New()` #[doc(alias = "vtkServerSocket")] pub fn new() -> Self { unsafe extern "C" { fn vtkServerSocket_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkServerSocket_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkServerSocket_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkServerSocket_get_ptr(self.0) } + Self(unsafe { vtkServerSocket_new() }) } } impl std::default::Default for vtkServerSocket { @@ -188,12 +951,8 @@ impl Drop for vtkServerSocket { #[test] fn test_vtkServerSocket_create_drop() { let obj = vtkServerSocket::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkServerSocket(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a collection for sockets. /// @@ -204,22 +963,13 @@ fn test_vtkServerSocket_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSocketCollection(*mut core::ffi::c_void); impl vtkSocketCollection { - /// Creates a new [vtkSocketCollection] wrapped inside `vtkNew` + /// Creates a new [vtkSocketCollection] via `vtkSocketCollection::New()` #[doc(alias = "vtkSocketCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkSocketCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSocketCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSocketCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSocketCollection_get_ptr(self.0) } + Self(unsafe { vtkSocketCollection_new() }) } } impl std::default::Default for vtkSocketCollection { @@ -239,12 +989,8 @@ impl Drop for vtkSocketCollection { #[test] fn test_vtkSocketCollection_create_drop() { let obj = vtkSocketCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSocketCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// A class for performing inter-thread messaging /// @@ -254,22 +1000,13 @@ fn test_vtkSocketCollection_create_drop() { #[allow(non_camel_case_types)] pub struct vtkThreadMessager(*mut core::ffi::c_void); impl vtkThreadMessager { - /// Creates a new [vtkThreadMessager] wrapped inside `vtkNew` + /// Creates a new [vtkThreadMessager] via `vtkThreadMessager::New()` #[doc(alias = "vtkThreadMessager")] pub fn new() -> Self { unsafe extern "C" { fn vtkThreadMessager_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkThreadMessager_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkThreadMessager_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkThreadMessager_get_ptr(self.0) } + Self(unsafe { vtkThreadMessager_new() }) } } impl std::default::Default for vtkThreadMessager { @@ -289,12 +1026,8 @@ impl Drop for vtkThreadMessager { #[test] fn test_vtkThreadMessager_create_drop() { let obj = vtkThreadMessager::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkThreadMessager(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// Timer support and logging /// @@ -309,22 +1042,13 @@ fn test_vtkThreadMessager_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTimerLog(*mut core::ffi::c_void); impl vtkTimerLog { - /// Creates a new [vtkTimerLog] wrapped inside `vtkNew` + /// Creates a new [vtkTimerLog] via `vtkTimerLog::New()` #[doc(alias = "vtkTimerLog")] pub fn new() -> Self { unsafe extern "C" { fn vtkTimerLog_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTimerLog_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTimerLog_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTimerLog_get_ptr(self.0) } + Self(unsafe { vtkTimerLog_new() }) } } impl std::default::Default for vtkTimerLog { @@ -344,10 +1068,6 @@ impl Drop for vtkTimerLog { #[test] fn test_vtkTimerLog_create_drop() { let obj = vtkTimerLog::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTimerLog(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkCommonTransforms.rs b/vtk-rs-9.1/src/vtkCommonTransforms.rs index 40447a0..a1fb269 100644 --- a/vtk-rs-9.1/src/vtkCommonTransforms.rs +++ b/vtk-rs-9.1/src/vtkCommonTransforms.rs @@ -1,3 +1,2005 @@ +pub trait VtkAbstractTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn transform_points( + &mut self, + inPts: *mut core::ffi::c_void, + outPts: *mut core::ffi::c_void, + ) -> (); + fn get_inverse(&mut self) -> *mut core::ffi::c_void; + fn set_inverse(&mut self, transform: *mut core::ffi::c_void) -> (); + fn inverse(&mut self) -> (); + fn deep_copy(&mut self, p0: *mut core::ffi::c_void) -> (); + fn update(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn circuit_check(&mut self, transform: *mut core::ffi::c_void) -> core::ffi::c_int; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn un_register(&mut self, O: *mut core::ffi::c_void) -> (); +} +pub trait VtkCylindricalTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkGeneralTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn identity(&mut self) -> (); + fn inverse(&mut self) -> (); + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn pre_multiply(&mut self) -> (); + fn post_multiply(&mut self) -> (); + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input(&mut self, input: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn push(&mut self) -> (); + fn pop(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkHomogeneousTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_matrix(&mut self, m: *mut core::ffi::c_void) -> (); + fn get_homogeneous_inverse(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkIdentityTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLandmarkTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> (); + fn set_target_landmarks(&mut self, target: *mut core::ffi::c_void) -> (); + fn get_source_landmarks(&mut self) -> *mut core::ffi::c_void; + fn get_target_landmarks(&mut self) -> *mut core::ffi::c_void; + fn set_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn set_mode_to_rigid_body(&mut self) -> (); + fn set_mode_to_similarity(&mut self) -> (); + fn set_mode_to_affine(&mut self) -> (); + fn get_mode(&mut self) -> core::ffi::c_int; + fn get_mode_as_string(&mut self) -> &str; + fn inverse(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkLinearTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn transform_normals( + &mut self, + inNms: *mut core::ffi::c_void, + outNms: *mut core::ffi::c_void, + ) -> (); + fn transform_vectors( + &mut self, + inVrs: *mut core::ffi::c_void, + outVrs: *mut core::ffi::c_void, + ) -> (); + fn get_linear_inverse(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkMatrixToHomogeneousTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_input(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkMatrixToLinearTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_input(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPerspectiveTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn identity(&mut self) -> (); + fn inverse(&mut self) -> (); + fn adjust_viewport( + &mut self, + oldXMin: core::ffi::c_double, + oldXMax: core::ffi::c_double, + oldYMin: core::ffi::c_double, + oldYMax: core::ffi::c_double, + newXMin: core::ffi::c_double, + newXMax: core::ffi::c_double, + newYMin: core::ffi::c_double, + newYMax: core::ffi::c_double, + ) -> (); + fn adjust_z_buffer( + &mut self, + oldNearZ: core::ffi::c_double, + oldFarZ: core::ffi::c_double, + newNearZ: core::ffi::c_double, + newFarZ: core::ffi::c_double, + ) -> (); + fn ortho( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> (); + fn frustum( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> (); + fn perspective( + &mut self, + angle: core::ffi::c_double, + aspect: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> (); + fn shear( + &mut self, + dxdz: core::ffi::c_double, + dydz: core::ffi::c_double, + zplane: core::ffi::c_double, + ) -> (); + fn stereo( + &mut self, + angle: core::ffi::c_double, + focaldistance: core::ffi::c_double, + ) -> (); + fn setup_camera( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + fp0: core::ffi::c_double, + fp1: core::ffi::c_double, + fp2: core::ffi::c_double, + vup0: core::ffi::c_double, + vup1: core::ffi::c_double, + vup2: core::ffi::c_double, + ) -> (); + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn pre_multiply(&mut self) -> (); + fn post_multiply(&mut self) -> (); + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn set_input(&mut self, input: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn push(&mut self) -> (); + fn pop(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkSphericalTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn make_transform(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkThinPlateSplineTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_sigma(&mut self) -> core::ffi::c_double; + fn set_sigma(&mut self, _arg: core::ffi::c_double) -> (); + fn set_basis(&mut self, basis: core::ffi::c_int) -> (); + fn get_basis(&mut self) -> core::ffi::c_int; + fn set_basis_to_r(&mut self) -> (); + fn set_basis_to_r_2_log_r(&mut self) -> (); + fn get_basis_as_string(&mut self) -> &str; + fn set_basis_function(&mut self, U: *mut core::ffi::c_void) -> (); + fn set_basis_derivative(&mut self, dUdr: *mut core::ffi::c_void) -> (); + fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> (); + fn get_source_landmarks(&mut self) -> *mut core::ffi::c_void; + fn set_target_landmarks(&mut self, target: *mut core::ffi::c_void) -> (); + fn get_target_landmarks(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn get_regularize_bulk_transform(&mut self) -> bool; + fn set_regularize_bulk_transform(&mut self, _arg: bool) -> (); + fn regularize_bulk_transform_on(&mut self) -> (); + fn regularize_bulk_transform_off(&mut self) -> (); +} +pub trait VtkTransform { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn identity(&mut self) -> (); + fn inverse(&mut self) -> (); + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate_x(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_y(&mut self, angle: core::ffi::c_double) -> (); + fn rotate_z(&mut self, angle: core::ffi::c_double) -> (); + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn pre_multiply(&mut self) -> (); + fn post_multiply(&mut self) -> (); + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int; + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> (); + fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> (); + fn set_input(&mut self, input: *mut core::ffi::c_void) -> (); + fn get_input(&mut self) -> *mut core::ffi::c_void; + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn push(&mut self) -> (); + fn pop(&mut self) -> (); + fn make_transform(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkTransform2D { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn identity(&mut self) -> (); + fn inverse(&mut self) -> (); + fn translate(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn rotate(&mut self, angle: core::ffi::c_double) -> (); + fn scale(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> (); + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> (); + fn get_matrix(&mut self) -> *mut core::ffi::c_void; + fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> (); + fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkTransformCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_next_item(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkTransformConcatenation { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn concatenate(&mut self, transform: *mut core::ffi::c_void) -> (); + fn set_pre_multiply_flag(&mut self, flag: core::ffi::c_int) -> (); + fn get_pre_multiply_flag(&mut self) -> core::ffi::c_int; + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn rotate( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn inverse(&mut self) -> (); + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn identity(&mut self) -> (); + fn deep_copy(&mut self, transform: *mut core::ffi::c_void) -> (); + fn get_number_of_transforms(&mut self) -> core::ffi::c_int; + fn get_number_of_pre_transforms(&mut self) -> core::ffi::c_int; + fn get_number_of_post_transforms(&mut self) -> core::ffi::c_int; + fn get_transform(&mut self, i: core::ffi::c_int) -> *mut core::ffi::c_void; + fn get_max_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkTransformConcatenationStack { + fn new(&mut self) -> *mut core::ffi::c_void; + fn delete(&mut self) -> (); + fn deep_copy(&mut self, stack: *mut core::ffi::c_void) -> (); +} +pub trait VtkTransformPair { + fn swap_forward_inverse(&mut self) -> (); +} +pub trait VtkWarpTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn inverse(&mut self) -> (); + fn get_inverse_flag(&mut self) -> core::ffi::c_int; + fn set_inverse_tolerance(&mut self, _arg: core::ffi::c_double) -> (); + fn get_inverse_tolerance(&mut self) -> core::ffi::c_double; + fn set_inverse_iterations(&mut self, _arg: core::ffi::c_int) -> (); + fn get_inverse_iterations(&mut self) -> core::ffi::c_int; +} +impl VtkCylindricalTransform for vtkCylindricalTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylindrical_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylindrical_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylindrical_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylindrical_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylindrical_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylindrical_transform_new_instance(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylindrical_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylindrical_transform_make_transform(self.0) } + } +} +impl VtkGeneralTransform for vtkGeneralTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_new_instance(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_identity(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_inverse(self.0) } + } + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_translate(self.0, x, y, z) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_wxyz(self.0, angle, x, y, z) } + } + fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_x( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_x(self.0, angle) } + } + fn rotate_y(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_y( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_y(self.0, angle) } + } + fn rotate_z(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_general_transform_rotate_z( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_rotate_z(self.0, angle) } + } + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_general_transform_scale( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_general_transform_scale(self.0, x, y, z) } + } + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_general_transform_concatenate( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_general_transform_concatenate(self.0, matrix) } + } + fn pre_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_pre_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_pre_multiply(self.0) } + } + fn post_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_post_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_post_multiply(self.0) } + } + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_general_transform_get_number_of_concatenated_transforms( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_general_transform_get_number_of_concatenated_transforms(self.0) } + } + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_get_concatenated_transform( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_get_concatenated_transform(self.0, i) } + } + fn set_input(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_general_transform_set_input( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_general_transform_set_input(self.0, input) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_get_input(self.0) } + } + fn get_inverse_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_general_transform_get_inverse_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_general_transform_get_inverse_flag(self.0) } + } + fn push(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_push(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_push(self.0) } + } + fn pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_general_transform_pop(sself: *mut core::ffi::c_void); + } + unsafe { vtk_general_transform_pop(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_general_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_general_transform_make_transform(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_general_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_general_transform_get_m_time(self.0) } + } +} +impl VtkIdentityTransform for vtkIdentityTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_identity_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_identity_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_identity_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_identity_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_identity_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_identity_transform_new_instance(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_identity_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_identity_transform_inverse(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_identity_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_identity_transform_make_transform(self.0) } + } +} +impl VtkLandmarkTransform for vtkLandmarkTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_new_instance(self.0) } + } + fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_source_landmarks( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_landmark_transform_set_source_landmarks(self.0, source) } + } + fn set_target_landmarks(&mut self, target: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_target_landmarks( + sself: *mut core::ffi::c_void, + target: *mut core::ffi::c_void, + ); + } + unsafe { vtk_landmark_transform_set_target_landmarks(self.0, target) } + } + fn get_source_landmarks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_get_source_landmarks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_get_source_landmarks(self.0) } + } + fn get_target_landmarks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_get_target_landmarks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_get_target_landmarks(self.0) } + } + fn set_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_landmark_transform_set_mode(self.0, _arg) } + } + fn set_mode_to_rigid_body(&mut self) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_mode_to_rigid_body( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_landmark_transform_set_mode_to_rigid_body(self.0) } + } + fn set_mode_to_similarity(&mut self) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_mode_to_similarity( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_landmark_transform_set_mode_to_similarity(self.0) } + } + fn set_mode_to_affine(&mut self) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_set_mode_to_affine(sself: *mut core::ffi::c_void); + } + unsafe { vtk_landmark_transform_set_mode_to_affine(self.0) } + } + fn get_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_landmark_transform_get_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_landmark_transform_get_mode(self.0) } + } + fn get_mode_as_string(&mut self) -> &str { + unsafe extern "C" { + fn vtk_landmark_transform_get_mode_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_landmark_transform_get_mode_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_landmark_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_landmark_transform_inverse(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_landmark_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_landmark_transform_get_m_time(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_landmark_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_landmark_transform_make_transform(self.0) } + } +} +impl VtkMatrixToHomogeneousTransform for vtkMatrixToHomogeneousTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_new_instance(self.0) } + } + fn set_input(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_set_input( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_to_homogeneous_transform_set_input(self.0, p0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_get_input(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_inverse( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_to_homogeneous_transform_inverse(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_matrix_to_homogeneous_transform_get_m_time(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_homogeneous_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_homogeneous_transform_make_transform(self.0) } + } +} +impl VtkMatrixToLinearTransform for vtkMatrixToLinearTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_new_instance(self.0) } + } + fn set_input(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_set_input( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_matrix_to_linear_transform_set_input(self.0, p0) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_get_input(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_matrix_to_linear_transform_inverse(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_matrix_to_linear_transform_get_m_time(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_matrix_to_linear_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_matrix_to_linear_transform_make_transform(self.0) } + } +} +impl VtkPerspectiveTransform for vtkPerspectiveTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_new_instance(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_identity(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_inverse(self.0) } + } + fn adjust_viewport( + &mut self, + oldXMin: core::ffi::c_double, + oldXMax: core::ffi::c_double, + oldYMin: core::ffi::c_double, + oldYMax: core::ffi::c_double, + newXMin: core::ffi::c_double, + newXMax: core::ffi::c_double, + newYMin: core::ffi::c_double, + newYMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_adjust_viewport( + sself: *mut core::ffi::c_void, + oldXMin: core::ffi::c_double, + oldXMax: core::ffi::c_double, + oldYMin: core::ffi::c_double, + oldYMax: core::ffi::c_double, + newXMin: core::ffi::c_double, + newXMax: core::ffi::c_double, + newYMin: core::ffi::c_double, + newYMax: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_adjust_viewport( + self.0, + oldXMin, + oldXMax, + oldYMin, + oldYMax, + newXMin, + newXMax, + newYMin, + newYMax, + ) + } + } + fn adjust_z_buffer( + &mut self, + oldNearZ: core::ffi::c_double, + oldFarZ: core::ffi::c_double, + newNearZ: core::ffi::c_double, + newFarZ: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_adjust_z_buffer( + sself: *mut core::ffi::c_void, + oldNearZ: core::ffi::c_double, + oldFarZ: core::ffi::c_double, + newNearZ: core::ffi::c_double, + newFarZ: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_adjust_z_buffer( + self.0, + oldNearZ, + oldFarZ, + newNearZ, + newFarZ, + ) + } + } + fn ortho( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_ortho( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_ortho(self.0, xmin, xmax, ymin, ymax, znear, zfar) + } + } + fn frustum( + &mut self, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_frustum( + sself: *mut core::ffi::c_void, + xmin: core::ffi::c_double, + xmax: core::ffi::c_double, + ymin: core::ffi::c_double, + ymax: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_frustum( + self.0, + xmin, + xmax, + ymin, + ymax, + znear, + zfar, + ) + } + } + fn perspective( + &mut self, + angle: core::ffi::c_double, + aspect: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_perspective( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + aspect: core::ffi::c_double, + znear: core::ffi::c_double, + zfar: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_perspective(self.0, angle, aspect, znear, zfar) + } + } + fn shear( + &mut self, + dxdz: core::ffi::c_double, + dydz: core::ffi::c_double, + zplane: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_shear( + sself: *mut core::ffi::c_void, + dxdz: core::ffi::c_double, + dydz: core::ffi::c_double, + zplane: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_shear(self.0, dxdz, dydz, zplane) } + } + fn stereo( + &mut self, + angle: core::ffi::c_double, + focaldistance: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_stereo( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + focaldistance: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_stereo(self.0, angle, focaldistance) } + } + fn setup_camera( + &mut self, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + fp0: core::ffi::c_double, + fp1: core::ffi::c_double, + fp2: core::ffi::c_double, + vup0: core::ffi::c_double, + vup1: core::ffi::c_double, + vup2: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_setup_camera( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_double, + p1: core::ffi::c_double, + p2: core::ffi::c_double, + fp0: core::ffi::c_double, + fp1: core::ffi::c_double, + fp2: core::ffi::c_double, + vup0: core::ffi::c_double, + vup1: core::ffi::c_double, + vup2: core::ffi::c_double, + ); + } + unsafe { + vtk_perspective_transform_setup_camera( + self.0, + p0, + p1, + p2, + fp0, + fp1, + fp2, + vup0, + vup1, + vup2, + ) + } + } + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_translate(self.0, x, y, z) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_wxyz(self.0, angle, x, y, z) } + } + fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_x( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_x(self.0, angle) } + } + fn rotate_y(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_y( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_y(self.0, angle) } + } + fn rotate_z(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_rotate_z( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_rotate_z(self.0, angle) } + } + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_scale( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_perspective_transform_scale(self.0, x, y, z) } + } + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_set_matrix( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_perspective_transform_set_matrix(self.0, matrix) } + } + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_concatenate( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_perspective_transform_concatenate(self.0, matrix) } + } + fn pre_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_pre_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_pre_multiply(self.0) } + } + fn post_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_post_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_post_multiply(self.0) } + } + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_perspective_transform_get_number_of_concatenated_transforms( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_perspective_transform_get_number_of_concatenated_transforms(self.0) + } + } + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_get_concatenated_transform( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_get_concatenated_transform(self.0, i) } + } + fn set_input(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_set_input( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_perspective_transform_set_input(self.0, input) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_get_input(self.0) } + } + fn get_inverse_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_perspective_transform_get_inverse_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_perspective_transform_get_inverse_flag(self.0) } + } + fn push(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_push(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_push(self.0) } + } + fn pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_perspective_transform_pop(sself: *mut core::ffi::c_void); + } + unsafe { vtk_perspective_transform_pop(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_perspective_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_perspective_transform_make_transform(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_perspective_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_perspective_transform_get_m_time(self.0) } + } +} +impl VtkSphericalTransform for vtkSphericalTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spherical_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spherical_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spherical_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spherical_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spherical_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spherical_transform_new_instance(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_spherical_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_spherical_transform_make_transform(self.0) } + } +} +impl VtkThinPlateSplineTransform for vtkThinPlateSplineTransform { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_new(self.0) } + } + fn get_sigma(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_sigma( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_thin_plate_spline_transform_get_sigma(self.0) } + } + fn set_sigma(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_sigma( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_sigma(self.0, _arg) } + } + fn set_basis(&mut self, basis: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis( + sself: *mut core::ffi::c_void, + basis: core::ffi::c_int, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis(self.0, basis) } + } + fn get_basis(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_basis( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_thin_plate_spline_transform_get_basis(self.0) } + } + fn set_basis_to_r(&mut self) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis_to_r( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis_to_r(self.0) } + } + fn set_basis_to_r_2_log_r(&mut self) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis_to_r_2_log_r(self.0) } + } + fn get_basis_as_string(&mut self) -> &str { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_basis_as_string( + sself: *mut core::ffi::c_void, + ) -> *const core::ffi::c_char; + } + let ptr = unsafe { vtk_thin_plate_spline_transform_get_basis_as_string(self.0) }; + if ptr.is_null() { + return ""; + } + unsafe { std::ffi::CStr::from_ptr(ptr).to_str().unwrap_or("") } + } + fn set_basis_function(&mut self, U: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis_function( + sself: *mut core::ffi::c_void, + U: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis_function(self.0, U) } + } + fn set_basis_derivative(&mut self, dUdr: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_basis_derivative( + sself: *mut core::ffi::c_void, + dUdr: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_basis_derivative(self.0, dUdr) } + } + fn set_source_landmarks(&mut self, source: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_source_landmarks( + sself: *mut core::ffi::c_void, + source: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_source_landmarks(self.0, source) } + } + fn get_source_landmarks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_source_landmarks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_get_source_landmarks(self.0) } + } + fn set_target_landmarks(&mut self, target: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_target_landmarks( + sself: *mut core::ffi::c_void, + target: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_set_target_landmarks(self.0, target) } + } + fn get_target_landmarks(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_target_landmarks( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_get_target_landmarks(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_thin_plate_spline_transform_get_m_time(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_thin_plate_spline_transform_make_transform(self.0) } + } + fn get_regularize_bulk_transform(&mut self) -> bool { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_get_regularize_bulk_transform( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_thin_plate_spline_transform_get_regularize_bulk_transform(self.0) } + } + fn set_regularize_bulk_transform(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_set_regularize_bulk_transform( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { + vtk_thin_plate_spline_transform_set_regularize_bulk_transform(self.0, _arg) + } + } + fn regularize_bulk_transform_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_regularize_bulk_transform_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_regularize_bulk_transform_on(self.0) } + } + fn regularize_bulk_transform_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_thin_plate_spline_transform_regularize_bulk_transform_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_thin_plate_spline_transform_regularize_bulk_transform_off(self.0) } + } +} +impl VtkTransform for vtkTransform { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_new_instance(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_identity(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_inverse(self.0) } + } + fn translate( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_transform_translate(self.0, x, y, z) } + } + fn rotate_wxyz( + &mut self, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_wxyz( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_wxyz(self.0, angle, x, y, z) } + } + fn rotate_x(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_x( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_x(self.0, angle) } + } + fn rotate_y(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_y( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_y(self.0, angle) } + } + fn rotate_z(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_rotate_z( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_transform_rotate_z(self.0, angle) } + } + fn scale( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_transform_scale( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_transform_scale(self.0, x, y, z) } + } + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_set_matrix( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_set_matrix(self.0, matrix) } + } + fn concatenate(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_concatenate( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_concatenate(self.0, matrix) } + } + fn pre_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_pre_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_pre_multiply(self.0) } + } + fn post_multiply(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_post_multiply(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_post_multiply(self.0) } + } + fn get_number_of_concatenated_transforms(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_transform_get_number_of_concatenated_transforms( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_transform_get_number_of_concatenated_transforms(self.0) } + } + fn get_concatenated_transform( + &mut self, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_get_concatenated_transform( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_get_concatenated_transform(self.0, i) } + } + fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_get_inverse( + sself: *mut core::ffi::c_void, + inverse: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_get_inverse(self.0, inverse) } + } + fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_get_transpose( + sself: *mut core::ffi::c_void, + transpose: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_get_transpose(self.0, transpose) } + } + fn set_input(&mut self, input: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_set_input( + sself: *mut core::ffi::c_void, + input: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_set_input(self.0, input) } + } + fn get_input(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_get_input( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_get_input(self.0) } + } + fn get_inverse_flag(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_transform_get_inverse_flag( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_transform_get_inverse_flag(self.0) } + } + fn push(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_push(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_push(self.0) } + } + fn pop(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_pop(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_pop(self.0) } + } + fn make_transform(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_make_transform( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_make_transform(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_transform_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_transform_get_m_time(self.0) } + } +} +impl VtkTransform2D for vtkTransform2D { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_2_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_2_d_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_2_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_2_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_2_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_2_d_new_instance(self.0) } + } + fn identity(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_identity(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_2_d_identity(self.0) } + } + fn inverse(&mut self) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_inverse(sself: *mut core::ffi::c_void); + } + unsafe { vtk_transform_2_d_inverse(self.0) } + } + fn translate(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_translate( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_translate(self.0, x, y) } + } + fn rotate(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_rotate( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_rotate(self.0, angle) } + } + fn scale(&mut self, x: core::ffi::c_double, y: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_scale( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + ); + } + unsafe { vtk_transform_2_d_scale(self.0, x, y) } + } + fn set_matrix(&mut self, matrix: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_set_matrix( + sself: *mut core::ffi::c_void, + matrix: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_set_matrix(self.0, matrix) } + } + fn get_matrix(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_2_d_get_matrix( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_2_d_get_matrix(self.0) } + } + fn get_inverse(&mut self, inverse: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_inverse( + sself: *mut core::ffi::c_void, + inverse: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_get_inverse(self.0, inverse) } + } + fn get_transpose(&mut self, transpose: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_2_d_get_transpose( + sself: *mut core::ffi::c_void, + transpose: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_2_d_get_transpose(self.0, transpose) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_transform_2_d_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_transform_2_d_get_m_time(self.0) } + } +} +impl VtkTransformCollection for vtkTransformCollection { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_new(self.0) } + } + fn add_item(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_transform_collection_add_item( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_transform_collection_add_item(self.0, p0) } + } + fn get_next_item(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_transform_collection_get_next_item( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_transform_collection_get_next_item(self.0) } + } +} /// cylindrical to rectangular coords and back /// /// @@ -14,22 +2016,13 @@ #[allow(non_camel_case_types)] pub struct vtkCylindricalTransform(*mut core::ffi::c_void); impl vtkCylindricalTransform { - /// Creates a new [vtkCylindricalTransform] wrapped inside `vtkNew` + /// Creates a new [vtkCylindricalTransform] via `vtkCylindricalTransform::New()` #[doc(alias = "vtkCylindricalTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkCylindricalTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkCylindricalTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkCylindricalTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkCylindricalTransform_get_ptr(self.0) } + Self(unsafe { vtkCylindricalTransform_new() }) } } impl std::default::Default for vtkCylindricalTransform { @@ -49,12 +2042,8 @@ impl Drop for vtkCylindricalTransform { #[test] fn test_vtkCylindricalTransform_create_drop() { let obj = vtkCylindricalTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkCylindricalTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// allows operations on any transforms /// @@ -70,22 +2059,13 @@ fn test_vtkCylindricalTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkGeneralTransform(*mut core::ffi::c_void); impl vtkGeneralTransform { - /// Creates a new [vtkGeneralTransform] wrapped inside `vtkNew` + /// Creates a new [vtkGeneralTransform] via `vtkGeneralTransform::New()` #[doc(alias = "vtkGeneralTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkGeneralTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkGeneralTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkGeneralTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkGeneralTransform_get_ptr(self.0) } + Self(unsafe { vtkGeneralTransform_new() }) } } impl std::default::Default for vtkGeneralTransform { @@ -105,12 +2085,8 @@ impl Drop for vtkGeneralTransform { #[test] fn test_vtkGeneralTransform_create_drop() { let obj = vtkGeneralTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkGeneralTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a transform that doesn't do anything /// @@ -123,22 +2099,13 @@ fn test_vtkGeneralTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkIdentityTransform(*mut core::ffi::c_void); impl vtkIdentityTransform { - /// Creates a new [vtkIdentityTransform] wrapped inside `vtkNew` + /// Creates a new [vtkIdentityTransform] via `vtkIdentityTransform::New()` #[doc(alias = "vtkIdentityTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkIdentityTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkIdentityTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkIdentityTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkIdentityTransform_get_ptr(self.0) } + Self(unsafe { vtkIdentityTransform_new() }) } } impl std::default::Default for vtkIdentityTransform { @@ -158,12 +2125,8 @@ impl Drop for vtkIdentityTransform { #[test] fn test_vtkIdentityTransform_create_drop() { let obj = vtkIdentityTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkIdentityTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a linear transform specified by two corresponding point sets /// @@ -182,22 +2145,13 @@ fn test_vtkIdentityTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkLandmarkTransform(*mut core::ffi::c_void); impl vtkLandmarkTransform { - /// Creates a new [vtkLandmarkTransform] wrapped inside `vtkNew` + /// Creates a new [vtkLandmarkTransform] via `vtkLandmarkTransform::New()` #[doc(alias = "vtkLandmarkTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkLandmarkTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkLandmarkTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkLandmarkTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkLandmarkTransform_get_ptr(self.0) } + Self(unsafe { vtkLandmarkTransform_new() }) } } impl std::default::Default for vtkLandmarkTransform { @@ -217,12 +2171,8 @@ impl Drop for vtkLandmarkTransform { #[test] fn test_vtkLandmarkTransform_create_drop() { let obj = vtkLandmarkTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkLandmarkTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// convert a matrix to a transform /// @@ -237,22 +2187,13 @@ fn test_vtkLandmarkTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMatrixToHomogeneousTransform(*mut core::ffi::c_void); impl vtkMatrixToHomogeneousTransform { - /// Creates a new [vtkMatrixToHomogeneousTransform] wrapped inside `vtkNew` + /// Creates a new [vtkMatrixToHomogeneousTransform] via `vtkMatrixToHomogeneousTransform::New()` #[doc(alias = "vtkMatrixToHomogeneousTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkMatrixToHomogeneousTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMatrixToHomogeneousTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMatrixToHomogeneousTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMatrixToHomogeneousTransform_get_ptr(self.0) } + Self(unsafe { vtkMatrixToHomogeneousTransform_new() }) } } impl std::default::Default for vtkMatrixToHomogeneousTransform { @@ -272,12 +2213,8 @@ impl Drop for vtkMatrixToHomogeneousTransform { #[test] fn test_vtkMatrixToHomogeneousTransform_create_drop() { let obj = vtkMatrixToHomogeneousTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMatrixToHomogeneousTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// convert a matrix to a transform /// @@ -292,22 +2229,13 @@ fn test_vtkMatrixToHomogeneousTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkMatrixToLinearTransform(*mut core::ffi::c_void); impl vtkMatrixToLinearTransform { - /// Creates a new [vtkMatrixToLinearTransform] wrapped inside `vtkNew` + /// Creates a new [vtkMatrixToLinearTransform] via `vtkMatrixToLinearTransform::New()` #[doc(alias = "vtkMatrixToLinearTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkMatrixToLinearTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkMatrixToLinearTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkMatrixToLinearTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkMatrixToLinearTransform_get_ptr(self.0) } + Self(unsafe { vtkMatrixToLinearTransform_new() }) } } impl std::default::Default for vtkMatrixToLinearTransform { @@ -327,12 +2255,8 @@ impl Drop for vtkMatrixToLinearTransform { #[test] fn test_vtkMatrixToLinearTransform_create_drop() { let obj = vtkMatrixToLinearTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkMatrixToLinearTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// describes a 4x4 matrix transformation /// @@ -363,22 +2287,13 @@ fn test_vtkMatrixToLinearTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkPerspectiveTransform(*mut core::ffi::c_void); impl vtkPerspectiveTransform { - /// Creates a new [vtkPerspectiveTransform] wrapped inside `vtkNew` + /// Creates a new [vtkPerspectiveTransform] via `vtkPerspectiveTransform::New()` #[doc(alias = "vtkPerspectiveTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkPerspectiveTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkPerspectiveTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkPerspectiveTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkPerspectiveTransform_get_ptr(self.0) } + Self(unsafe { vtkPerspectiveTransform_new() }) } } impl std::default::Default for vtkPerspectiveTransform { @@ -398,12 +2313,8 @@ impl Drop for vtkPerspectiveTransform { #[test] fn test_vtkPerspectiveTransform_create_drop() { let obj = vtkPerspectiveTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkPerspectiveTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// spherical to rectangular coords and back /// @@ -422,22 +2333,13 @@ fn test_vtkPerspectiveTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkSphericalTransform(*mut core::ffi::c_void); impl vtkSphericalTransform { - /// Creates a new [vtkSphericalTransform] wrapped inside `vtkNew` + /// Creates a new [vtkSphericalTransform] via `vtkSphericalTransform::New()` #[doc(alias = "vtkSphericalTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkSphericalTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkSphericalTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkSphericalTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkSphericalTransform_get_ptr(self.0) } + Self(unsafe { vtkSphericalTransform_new() }) } } impl std::default::Default for vtkSphericalTransform { @@ -457,12 +2359,8 @@ impl Drop for vtkSphericalTransform { #[test] fn test_vtkSphericalTransform_create_drop() { let obj = vtkSphericalTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkSphericalTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// a nonlinear warp transformation /// @@ -489,22 +2387,13 @@ fn test_vtkSphericalTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkThinPlateSplineTransform(*mut core::ffi::c_void); impl vtkThinPlateSplineTransform { - /// Creates a new [vtkThinPlateSplineTransform] wrapped inside `vtkNew` + /// Creates a new [vtkThinPlateSplineTransform] via `vtkThinPlateSplineTransform::New()` #[doc(alias = "vtkThinPlateSplineTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkThinPlateSplineTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkThinPlateSplineTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkThinPlateSplineTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkThinPlateSplineTransform_get_ptr(self.0) } + Self(unsafe { vtkThinPlateSplineTransform_new() }) } } impl std::default::Default for vtkThinPlateSplineTransform { @@ -524,12 +2413,8 @@ impl Drop for vtkThinPlateSplineTransform { #[test] fn test_vtkThinPlateSplineTransform_create_drop() { let obj = vtkThinPlateSplineTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkThinPlateSplineTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// describes linear transformations via a 4x4 matrix /// @@ -561,22 +2446,13 @@ fn test_vtkThinPlateSplineTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTransform(*mut core::ffi::c_void); impl vtkTransform { - /// Creates a new [vtkTransform] wrapped inside `vtkNew` + /// Creates a new [vtkTransform] via `vtkTransform::New()` #[doc(alias = "vtkTransform")] pub fn new() -> Self { unsafe extern "C" { fn vtkTransform_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTransform_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTransform_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTransform_get_ptr(self.0) } + Self(unsafe { vtkTransform_new() }) } } impl std::default::Default for vtkTransform { @@ -596,12 +2472,8 @@ impl Drop for vtkTransform { #[test] fn test_vtkTransform_create_drop() { let obj = vtkTransform::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTransform(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// describes linear transformations via a 3x3 matrix /// @@ -622,22 +2494,13 @@ fn test_vtkTransform_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTransform2D(*mut core::ffi::c_void); impl vtkTransform2D { - /// Creates a new [vtkTransform2D] wrapped inside `vtkNew` + /// Creates a new [vtkTransform2D] via `vtkTransform2D::New()` #[doc(alias = "vtkTransform2D")] pub fn new() -> Self { unsafe extern "C" { fn vtkTransform2D_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTransform2D_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTransform2D_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTransform2D_get_ptr(self.0) } + Self(unsafe { vtkTransform2D_new() }) } } impl std::default::Default for vtkTransform2D { @@ -657,12 +2520,8 @@ impl Drop for vtkTransform2D { #[test] fn test_vtkTransform2D_create_drop() { let obj = vtkTransform2D::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTransform2D(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } /// maintain a list of transforms /// @@ -676,22 +2535,13 @@ fn test_vtkTransform2D_create_drop() { #[allow(non_camel_case_types)] pub struct vtkTransformCollection(*mut core::ffi::c_void); impl vtkTransformCollection { - /// Creates a new [vtkTransformCollection] wrapped inside `vtkNew` + /// Creates a new [vtkTransformCollection] via `vtkTransformCollection::New()` #[doc(alias = "vtkTransformCollection")] pub fn new() -> Self { unsafe extern "C" { fn vtkTransformCollection_new() -> *mut core::ffi::c_void; } - Self(unsafe { &mut *vtkTransformCollection_new() }) - } - #[cfg(test)] - unsafe fn _get_ptr(&self) -> *mut core::ffi::c_void { - unsafe extern "C" { - fn vtkTransformCollection_get_ptr( - sself: *mut core::ffi::c_void, - ) -> *mut core::ffi::c_void; - } - unsafe { vtkTransformCollection_get_ptr(self.0) } + Self(unsafe { vtkTransformCollection_new() }) } } impl std::default::Default for vtkTransformCollection { @@ -711,10 +2561,6 @@ impl Drop for vtkTransformCollection { #[test] fn test_vtkTransformCollection_create_drop() { let obj = vtkTransformCollection::new(); - let ptr = obj.0; - assert!(!ptr.is_null()); - assert!(unsafe { !obj._get_ptr().is_null() }); + assert!(!obj.0.is_null()); drop(obj); - let new_obj = vtkTransformCollection(ptr); - assert!(unsafe { new_obj._get_ptr().is_null() }); } diff --git a/vtk-rs-9.1/src/vtkFiltersSources.rs b/vtk-rs-9.1/src/vtkFiltersSources.rs new file mode 100644 index 0000000..3d3d6b6 --- /dev/null +++ b/vtk-rs-9.1/src/vtkFiltersSources.rs @@ -0,0 +1,10307 @@ +pub trait VtkArcSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_point_1( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_point_2( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_polar_vector( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_angle_min_value(&mut self) -> core::ffi::c_double; + fn get_angle_max_value(&mut self) -> core::ffi::c_double; + fn get_angle(&mut self) -> core::ffi::c_double; + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_negative(&mut self, _arg: bool) -> (); + fn get_negative(&mut self) -> bool; + fn negative_on(&mut self) -> (); + fn negative_off(&mut self) -> (); + fn set_use_normal_and_angle(&mut self, _arg: bool) -> (); + fn get_use_normal_and_angle(&mut self) -> bool; + fn use_normal_and_angle_on(&mut self) -> (); + fn use_normal_and_angle_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkArrowSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_tip_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tip_length_min_value(&mut self) -> core::ffi::c_double; + fn get_tip_length_max_value(&mut self) -> core::ffi::c_double; + fn get_tip_length(&mut self) -> core::ffi::c_double; + fn set_tip_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_tip_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_tip_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_tip_radius(&mut self) -> core::ffi::c_double; + fn set_tip_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_tip_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_tip_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_tip_resolution(&mut self) -> core::ffi::c_int; + fn set_shaft_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_shaft_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_shaft_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_shaft_radius(&mut self) -> core::ffi::c_double; + fn set_shaft_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_shaft_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_shaft_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_shaft_resolution(&mut self) -> core::ffi::c_int; + fn invert_on(&mut self) -> (); + fn invert_off(&mut self) -> (); + fn set_invert(&mut self, _arg: bool) -> (); + fn get_invert(&mut self) -> bool; + fn set_arrow_origin_to_default(&mut self) -> (); + fn set_arrow_origin_to_center(&mut self) -> (); +} +pub trait VtkButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_texture_style(&mut self, _arg: core::ffi::c_int) -> (); + fn get_texture_style_min_value(&mut self) -> core::ffi::c_int; + fn get_texture_style_max_value(&mut self) -> core::ffi::c_int; + fn get_texture_style(&mut self) -> core::ffi::c_int; + fn set_texture_style_to_fit_image(&mut self) -> (); + fn set_texture_style_to_proportional(&mut self) -> (); + fn set_texture_dimensions( + &mut self, + _arg1: core::ffi::c_int, + _arg2: core::ffi::c_int, + ) -> (); + fn set_shoulder_texture_coordinate( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + ) -> (); + fn set_two_sided(&mut self, _arg: core::ffi::c_int) -> (); + fn get_two_sided(&mut self) -> core::ffi::c_int; + fn two_sided_on(&mut self) -> (); + fn two_sided_off(&mut self) -> (); +} +pub trait VtkCapsuleSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_cylinder_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_cylinder_length_min_value(&mut self) -> core::ffi::c_double; + fn get_cylinder_length_max_value(&mut self) -> core::ffi::c_double; + fn get_cylinder_length(&mut self) -> core::ffi::c_double; + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution(&mut self) -> core::ffi::c_int; + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution(&mut self) -> core::ffi::c_int; + fn set_lat_long_tessellation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_lat_long_tessellation(&mut self) -> core::ffi::c_int; + fn lat_long_tessellation_on(&mut self) -> (); + fn lat_long_tessellation_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkCellTypeSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> (); + fn get_cell_type(&mut self) -> core::ffi::c_int; + fn set_cell_order(&mut self, _arg: core::ffi::c_int) -> (); + fn get_cell_order(&mut self) -> core::ffi::c_int; + fn set_complete_quadratic_simplicial_elements(&mut self, _arg: bool) -> (); + fn get_complete_quadratic_simplicial_elements(&mut self) -> bool; + fn complete_quadratic_simplicial_elements_on(&mut self) -> (); + fn complete_quadratic_simplicial_elements_off(&mut self) -> (); + fn set_polynomial_field_order(&mut self, _arg: core::ffi::c_int) -> (); + fn get_polynomial_field_order_min_value(&mut self) -> core::ffi::c_int; + fn get_polynomial_field_order_max_value(&mut self) -> core::ffi::c_int; + fn get_polynomial_field_order(&mut self) -> core::ffi::c_int; + fn get_cell_dimension(&mut self) -> core::ffi::c_int; + fn set_output_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_precision_min_value(&mut self) -> core::ffi::c_int; + fn get_output_precision_max_value(&mut self) -> core::ffi::c_int; + fn get_output_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkConeSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_height(&mut self, _arg: core::ffi::c_double) -> (); + fn get_height_min_value(&mut self) -> core::ffi::c_double; + fn get_height_max_value(&mut self) -> core::ffi::c_double; + fn get_height(&mut self) -> core::ffi::c_double; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_direction( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_angle(&mut self, angle: core::ffi::c_double) -> (); + fn get_angle(&mut self) -> core::ffi::c_double; + fn set_capping(&mut self, _arg: core::ffi::c_int) -> (); + fn get_capping(&mut self) -> core::ffi::c_int; + fn capping_on(&mut self) -> (); + fn capping_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkCubeSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_x_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_x_length_min_value(&mut self) -> core::ffi::c_double; + fn get_x_length_max_value(&mut self) -> core::ffi::c_double; + fn get_x_length(&mut self) -> core::ffi::c_double; + fn set_y_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_y_length_min_value(&mut self) -> core::ffi::c_double; + fn get_y_length_max_value(&mut self) -> core::ffi::c_double; + fn get_y_length(&mut self) -> core::ffi::c_double; + fn set_z_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_z_length_min_value(&mut self) -> core::ffi::c_double; + fn get_z_length_max_value(&mut self) -> core::ffi::c_double; + fn get_z_length(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkCylinderSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_height(&mut self, _arg: core::ffi::c_double) -> (); + fn get_height_min_value(&mut self) -> core::ffi::c_double; + fn get_height_max_value(&mut self) -> core::ffi::c_double; + fn get_height(&mut self) -> core::ffi::c_double; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_capping(&mut self, _arg: core::ffi::c_int) -> (); + fn get_capping(&mut self) -> core::ffi::c_int; + fn capping_on(&mut self) -> (); + fn capping_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkDiagonalMatrixSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_array_type(&mut self) -> core::ffi::c_int; + fn set_array_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_extents(&mut self) -> core::ffi::c_longlong; + fn set_extents(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_diagonal(&mut self) -> core::ffi::c_double; + fn set_diagonal(&mut self, _arg: core::ffi::c_double) -> (); + fn get_super_diagonal(&mut self) -> core::ffi::c_double; + fn set_super_diagonal(&mut self, _arg: core::ffi::c_double) -> (); + fn get_sub_diagonal(&mut self) -> core::ffi::c_double; + fn set_sub_diagonal(&mut self, _arg: core::ffi::c_double) -> (); + fn set_row_label(&mut self, _arg: &str) -> (); + fn set_column_label(&mut self, _arg: &str) -> (); +} +pub trait VtkDiskSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_inner_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_inner_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_inner_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_inner_radius(&mut self) -> core::ffi::c_double; + fn set_outer_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_outer_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_outer_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_outer_radius(&mut self) -> core::ffi::c_double; + fn set_radial_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_radial_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_radial_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_radial_resolution(&mut self) -> core::ffi::c_int; + fn set_circumferential_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_circumferential_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_circumferential_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_circumferential_resolution(&mut self) -> core::ffi::c_int; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkEllipseArcSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_major_radius_vector( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_start_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_start_angle_min_value(&mut self) -> core::ffi::c_double; + fn get_start_angle_max_value(&mut self) -> core::ffi::c_double; + fn get_start_angle(&mut self) -> core::ffi::c_double; + fn set_segment_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_segment_angle_min_value(&mut self) -> core::ffi::c_double; + fn get_segment_angle_max_value(&mut self) -> core::ffi::c_double; + fn get_segment_angle(&mut self) -> core::ffi::c_double; + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_close(&mut self, _arg: bool) -> (); + fn get_close(&mut self) -> bool; + fn close_on(&mut self) -> (); + fn close_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; + fn set_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_ratio(&mut self) -> core::ffi::c_double; +} +pub trait VtkEllipticalButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_width(&mut self, _arg: core::ffi::c_double) -> (); + fn get_width_min_value(&mut self) -> core::ffi::c_double; + fn get_width_max_value(&mut self) -> core::ffi::c_double; + fn get_width(&mut self) -> core::ffi::c_double; + fn set_height(&mut self, _arg: core::ffi::c_double) -> (); + fn get_height_min_value(&mut self) -> core::ffi::c_double; + fn get_height_max_value(&mut self) -> core::ffi::c_double; + fn get_height(&mut self) -> core::ffi::c_double; + fn set_depth(&mut self, _arg: core::ffi::c_double) -> (); + fn get_depth_min_value(&mut self) -> core::ffi::c_double; + fn get_depth_max_value(&mut self) -> core::ffi::c_double; + fn get_depth(&mut self) -> core::ffi::c_double; + fn set_circumferential_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_circumferential_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_circumferential_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_circumferential_resolution(&mut self) -> core::ffi::c_int; + fn set_texture_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_texture_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_texture_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_texture_resolution(&mut self) -> core::ffi::c_int; + fn set_shoulder_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_shoulder_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_shoulder_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_shoulder_resolution(&mut self) -> core::ffi::c_int; + fn set_radial_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radial_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_radial_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_radial_ratio(&mut self) -> core::ffi::c_double; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkFrustumSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn get_planes(&mut self) -> *mut core::ffi::c_void; + fn set_planes(&mut self, planes: *mut core::ffi::c_void) -> (); + fn get_show_lines(&mut self) -> bool; + fn set_show_lines(&mut self, _arg: bool) -> (); + fn show_lines_on(&mut self) -> (); + fn show_lines_off(&mut self) -> (); + fn get_lines_length(&mut self) -> core::ffi::c_double; + fn set_lines_length(&mut self, _arg: core::ffi::c_double) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkGlyphSource2D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_scale(&mut self, _arg: core::ffi::c_double) -> (); + fn get_scale_min_value(&mut self) -> core::ffi::c_double; + fn get_scale_max_value(&mut self) -> core::ffi::c_double; + fn get_scale(&mut self) -> core::ffi::c_double; + fn set_scale_2(&mut self, _arg: core::ffi::c_double) -> (); + fn get_scale_2_min_value(&mut self) -> core::ffi::c_double; + fn get_scale_2_max_value(&mut self) -> core::ffi::c_double; + fn get_scale_2(&mut self) -> core::ffi::c_double; + fn set_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_filled(&mut self, _arg: core::ffi::c_int) -> (); + fn get_filled(&mut self) -> core::ffi::c_int; + fn filled_on(&mut self) -> (); + fn filled_off(&mut self) -> (); + fn set_dash(&mut self, _arg: core::ffi::c_int) -> (); + fn get_dash(&mut self) -> core::ffi::c_int; + fn dash_on(&mut self) -> (); + fn dash_off(&mut self) -> (); + fn set_cross(&mut self, _arg: core::ffi::c_int) -> (); + fn get_cross(&mut self) -> core::ffi::c_int; + fn cross_on(&mut self) -> (); + fn cross_off(&mut self) -> (); + fn set_rotation_angle(&mut self, _arg: core::ffi::c_double) -> (); + fn get_rotation_angle(&mut self) -> core::ffi::c_double; + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_glyph_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_glyph_type_min_value(&mut self) -> core::ffi::c_int; + fn get_glyph_type_max_value(&mut self) -> core::ffi::c_int; + fn get_glyph_type(&mut self) -> core::ffi::c_int; + fn set_glyph_type_to_none(&mut self) -> (); + fn set_glyph_type_to_vertex(&mut self) -> (); + fn set_glyph_type_to_dash(&mut self) -> (); + fn set_glyph_type_to_cross(&mut self) -> (); + fn set_glyph_type_to_thick_cross(&mut self) -> (); + fn set_glyph_type_to_triangle(&mut self) -> (); + fn set_glyph_type_to_square(&mut self) -> (); + fn set_glyph_type_to_circle(&mut self) -> (); + fn set_glyph_type_to_diamond(&mut self) -> (); + fn set_glyph_type_to_arrow(&mut self) -> (); + fn set_glyph_type_to_thick_arrow(&mut self) -> (); + fn set_glyph_type_to_hooked_arrow(&mut self) -> (); + fn set_glyph_type_to_edge_arrow(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkGraphToPolyData { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_edge_glyph_output(&mut self, _arg: bool) -> (); + fn get_edge_glyph_output(&mut self) -> bool; + fn edge_glyph_output_on(&mut self) -> (); + fn edge_glyph_output_off(&mut self) -> (); + fn set_edge_glyph_position(&mut self, _arg: core::ffi::c_double) -> (); + fn get_edge_glyph_position(&mut self) -> core::ffi::c_double; +} +pub trait VtkHandleSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_directional(&mut self, _arg: bool) -> (); + fn get_directional(&mut self) -> bool; + fn directional_on(&mut self) -> (); + fn directional_off(&mut self) -> (); + fn set_position( + &mut self, + xPos: core::ffi::c_double, + yPos: core::ffi::c_double, + zPos: core::ffi::c_double, + ) -> (); + fn set_direction( + &mut self, + xDir: core::ffi::c_double, + yDir: core::ffi::c_double, + zDir: core::ffi::c_double, + ) -> (); + fn set_size(&mut self, _arg: core::ffi::c_double) -> (); + fn get_size(&mut self) -> core::ffi::c_double; +} +pub trait VtkHyperTreeGridSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn get_maximum_level(&mut self) -> core::ffi::c_uint; + fn set_maximum_level(&mut self, levels: core::ffi::c_uint) -> (); + fn get_max_depth(&mut self) -> core::ffi::c_uint; + fn set_max_depth(&mut self, levels: core::ffi::c_uint) -> (); + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_grid_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_transposed_root_indexing(&mut self, _arg: bool) -> (); + fn get_transposed_root_indexing(&mut self) -> bool; + fn set_indexing_mode_to_kji(&mut self) -> (); + fn set_indexing_mode_to_ijk(&mut self) -> (); + fn get_orientation(&mut self) -> core::ffi::c_uint; + fn set_branch_factor(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_branch_factor_min_value(&mut self) -> core::ffi::c_uint; + fn get_branch_factor_max_value(&mut self) -> core::ffi::c_uint; + fn get_branch_factor(&mut self) -> core::ffi::c_uint; + fn set_use_descriptor(&mut self, _arg: bool) -> (); + fn get_use_descriptor(&mut self) -> bool; + fn use_descriptor_on(&mut self) -> (); + fn use_descriptor_off(&mut self) -> (); + fn set_use_mask(&mut self, _arg: bool) -> (); + fn get_use_mask(&mut self) -> bool; + fn use_mask_on(&mut self) -> (); + fn use_mask_off(&mut self) -> (); + fn set_generate_interface_fields(&mut self, _arg: bool) -> (); + fn get_generate_interface_fields(&mut self) -> bool; + fn generate_interface_fields_on(&mut self) -> (); + fn generate_interface_fields_off(&mut self) -> (); + fn set_descriptor(&mut self, _arg: &str) -> (); + fn set_mask(&mut self, _arg: &str) -> (); + fn set_descriptor_bits(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_descriptor_bits(&mut self) -> *mut core::ffi::c_void; + fn set_level_zero_material_index(&mut self, p0: *mut core::ffi::c_void) -> (); + fn set_mask_bits(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_mask_bits(&mut self) -> *mut core::ffi::c_void; + fn set_quadric(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_quadric(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn convert_descriptor_string_to_bit_array( + &mut self, + p0: &str, + ) -> *mut core::ffi::c_void; + fn convert_mask_string_to_bit_array(&mut self, p0: &str) -> *mut core::ffi::c_void; +} +pub trait VtkLineSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_point_1( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_point_2( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_use_regular_refinement(&mut self, _arg: bool) -> (); + fn get_use_regular_refinement(&mut self) -> bool; + fn use_regular_refinement_on(&mut self) -> (); + fn use_regular_refinement_off(&mut self) -> (); + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_resolution(&mut self) -> core::ffi::c_int; + fn set_number_of_refinement_ratios(&mut self, p0: core::ffi::c_int) -> (); + fn set_refinement_ratio( + &mut self, + index: core::ffi::c_int, + value: core::ffi::c_double, + ) -> (); + fn get_number_of_refinement_ratios(&mut self) -> core::ffi::c_int; + fn get_refinement_ratio(&mut self, index: core::ffi::c_int) -> core::ffi::c_double; + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkOutlineCornerFilter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_corner_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_corner_factor_min_value(&mut self) -> core::ffi::c_double; + fn get_corner_factor_max_value(&mut self) -> core::ffi::c_double; + fn get_corner_factor(&mut self) -> core::ffi::c_double; +} +pub trait VtkOutlineCornerSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_corner_factor(&mut self, _arg: core::ffi::c_double) -> (); + fn get_corner_factor_min_value(&mut self) -> core::ffi::c_double; + fn get_corner_factor_max_value(&mut self) -> core::ffi::c_double; + fn get_corner_factor(&mut self) -> core::ffi::c_double; +} +pub trait VtkOutlineSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_box_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_box_type(&mut self) -> core::ffi::c_int; + fn set_box_type_to_axis_aligned(&mut self) -> (); + fn set_box_type_to_oriented(&mut self) -> (); + fn set_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> (); + fn set_generate_faces(&mut self, _arg: core::ffi::c_int) -> (); + fn generate_faces_on(&mut self) -> (); + fn generate_faces_off(&mut self) -> (); + fn get_generate_faces(&mut self) -> core::ffi::c_int; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkParametricFunctionSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_parametric_function(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_parametric_function(&mut self) -> *mut core::ffi::c_void; + fn set_u_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_u_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_u_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_u_resolution(&mut self) -> core::ffi::c_int; + fn set_v_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_v_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_v_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_v_resolution(&mut self) -> core::ffi::c_int; + fn set_w_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_w_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_w_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_w_resolution(&mut self) -> core::ffi::c_int; + fn generate_texture_coordinates_on(&mut self) -> (); + fn generate_texture_coordinates_off(&mut self) -> (); + fn set_generate_texture_coordinates(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_texture_coordinates_min_value(&mut self) -> core::ffi::c_int; + fn get_generate_texture_coordinates_max_value(&mut self) -> core::ffi::c_int; + fn get_generate_texture_coordinates(&mut self) -> core::ffi::c_int; + fn generate_normals_on(&mut self) -> (); + fn generate_normals_off(&mut self) -> (); + fn set_generate_normals(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_normals_min_value(&mut self) -> core::ffi::c_int; + fn get_generate_normals_max_value(&mut self) -> core::ffi::c_int; + fn get_generate_normals(&mut self) -> core::ffi::c_int; + fn set_scalar_mode(&mut self, _arg: core::ffi::c_int) -> (); + fn get_scalar_mode_min_value(&mut self) -> core::ffi::c_int; + fn get_scalar_mode_max_value(&mut self) -> core::ffi::c_int; + fn get_scalar_mode(&mut self) -> core::ffi::c_int; + fn set_scalar_mode_to_none(&mut self) -> (); + fn set_scalar_mode_to_u(&mut self) -> (); + fn set_scalar_mode_to_v(&mut self) -> (); + fn set_scalar_mode_to_u_0(&mut self) -> (); + fn set_scalar_mode_to_v_0(&mut self) -> (); + fn set_scalar_mode_to_u_0_v_0(&mut self) -> (); + fn set_scalar_mode_to_modulus(&mut self) -> (); + fn set_scalar_mode_to_phase(&mut self) -> (); + fn set_scalar_mode_to_quadrant(&mut self) -> (); + fn set_scalar_mode_to_x(&mut self) -> (); + fn set_scalar_mode_to_y(&mut self) -> (); + fn set_scalar_mode_to_z(&mut self) -> (); + fn set_scalar_mode_to_distance(&mut self) -> (); + fn set_scalar_mode_to_function_defined(&mut self) -> (); + fn get_m_time(&mut self) -> core::ffi::c_ulong; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkPartitionedDataSetCollectionSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_shapes(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_shapes_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_shapes_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_shapes(&mut self) -> core::ffi::c_int; +} +pub trait VtkPartitionedDataSetSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn enable_rank(&mut self, rank: core::ffi::c_int) -> (); + fn enable_all_ranks(&mut self) -> (); + fn disable_rank(&mut self, rank: core::ffi::c_int) -> (); + fn disable_all_ranks(&mut self) -> (); + fn is_enabled_rank(&mut self, rank: core::ffi::c_int) -> bool; + fn set_number_of_partitions(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_partitions_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_partitions_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_partitions(&mut self) -> core::ffi::c_int; + fn set_parametric_function(&mut self, p0: *mut core::ffi::c_void) -> (); + fn get_parametric_function(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPlaneSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_x_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_x_resolution(&mut self) -> core::ffi::c_int; + fn set_y_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_y_resolution(&mut self) -> core::ffi::c_int; + fn set_resolution(&mut self, xR: core::ffi::c_int, yR: core::ffi::c_int) -> (); + fn get_resolution( + &mut self, + xR: &mut core::ffi::c_int, + yR: &mut core::ffi::c_int, + ) -> (); + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_point_1( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_point_2( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_center( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + nx: core::ffi::c_double, + ny: core::ffi::c_double, + nz: core::ffi::c_double, + ) -> (); + fn push(&mut self, distance: core::ffi::c_double) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkPlatonicSolidSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_solid_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_solid_type_min_value(&mut self) -> core::ffi::c_int; + fn get_solid_type_max_value(&mut self) -> core::ffi::c_int; + fn get_solid_type(&mut self) -> core::ffi::c_int; + fn set_solid_type_to_tetrahedron(&mut self) -> (); + fn set_solid_type_to_cube(&mut self) -> (); + fn set_solid_type_to_octahedron(&mut self) -> (); + fn set_solid_type_to_icosahedron(&mut self) -> (); + fn set_solid_type_to_dodecahedron(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkPointHandleSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_position( + &mut self, + xPos: core::ffi::c_double, + yPos: core::ffi::c_double, + zPos: core::ffi::c_double, + ) -> (); + fn set_direction( + &mut self, + xDir: core::ffi::c_double, + yDir: core::ffi::c_double, + zDir: core::ffi::c_double, + ) -> (); +} +pub trait VtkPointSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_number_of_points_min_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_points_max_value(&mut self) -> core::ffi::c_longlong; + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_distribution(&mut self, _arg: core::ffi::c_int) -> (); + fn set_distribution_to_uniform(&mut self) -> (); + fn set_distribution_to_shell(&mut self) -> (); + fn get_distribution(&mut self) -> core::ffi::c_int; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; + fn set_random_sequence(&mut self, randomSequence: *mut core::ffi::c_void) -> (); + fn get_random_sequence(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkPolyLineSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_closed(&mut self, _arg: core::ffi::c_int) -> (); + fn get_closed(&mut self) -> core::ffi::c_int; + fn closed_on(&mut self) -> (); + fn closed_off(&mut self) -> (); +} +pub trait VtkPolyPointSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> (); + fn get_number_of_points(&mut self) -> core::ffi::c_longlong; + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> (); + fn set_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn set_points(&mut self, points: *mut core::ffi::c_void) -> (); + fn get_points(&mut self) -> *mut core::ffi::c_void; + fn get_m_time(&mut self) -> core::ffi::c_ulong; +} +pub trait VtkProgrammableDataObjectSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_execute_method_arg_delete(&mut self, f: *mut core::ffi::c_void) -> (); +} +pub trait VtkProgrammableSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_execute_method_arg_delete(&mut self, f: *mut core::ffi::c_void) -> (); + fn set_request_information_method(&mut self, f: *mut core::ffi::c_void) -> (); + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void; + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void; + fn get_graph_output(&mut self) -> *mut core::ffi::c_void; + fn get_molecule_output(&mut self) -> *mut core::ffi::c_void; + fn get_table_output(&mut self) -> *mut core::ffi::c_void; +} +pub trait VtkRandomHyperTreeGridSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_dimensions( + &mut self, + _arg1: core::ffi::c_uint, + _arg2: core::ffi::c_uint, + _arg3: core::ffi::c_uint, + ) -> (); + fn set_output_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> (); + fn get_seed(&mut self) -> core::ffi::c_uint; + fn set_seed(&mut self, _arg: core::ffi::c_uint) -> (); + fn get_max_depth(&mut self) -> core::ffi::c_longlong; + fn set_max_depth(&mut self, _arg: core::ffi::c_longlong) -> (); + fn get_max_depth_min_value(&mut self) -> core::ffi::c_longlong; + fn get_max_depth_max_value(&mut self) -> core::ffi::c_longlong; + fn get_split_fraction(&mut self) -> core::ffi::c_double; + fn set_split_fraction(&mut self, _arg: core::ffi::c_double) -> (); + fn get_split_fraction_min_value(&mut self) -> core::ffi::c_double; + fn get_split_fraction_max_value(&mut self) -> core::ffi::c_double; +} +pub trait VtkRectangularButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_width(&mut self, _arg: core::ffi::c_double) -> (); + fn get_width_min_value(&mut self) -> core::ffi::c_double; + fn get_width_max_value(&mut self) -> core::ffi::c_double; + fn get_width(&mut self) -> core::ffi::c_double; + fn set_height(&mut self, _arg: core::ffi::c_double) -> (); + fn get_height_min_value(&mut self) -> core::ffi::c_double; + fn get_height_max_value(&mut self) -> core::ffi::c_double; + fn get_height(&mut self) -> core::ffi::c_double; + fn set_depth(&mut self, _arg: core::ffi::c_double) -> (); + fn get_depth_min_value(&mut self) -> core::ffi::c_double; + fn get_depth_max_value(&mut self) -> core::ffi::c_double; + fn get_depth(&mut self) -> core::ffi::c_double; + fn set_box_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_box_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_box_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_box_ratio(&mut self) -> core::ffi::c_double; + fn set_texture_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_texture_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_texture_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_texture_ratio(&mut self) -> core::ffi::c_double; + fn set_texture_height_ratio(&mut self, _arg: core::ffi::c_double) -> (); + fn get_texture_height_ratio_min_value(&mut self) -> core::ffi::c_double; + fn get_texture_height_ratio_max_value(&mut self) -> core::ffi::c_double; + fn get_texture_height_ratio(&mut self) -> core::ffi::c_double; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkRegularPolygonSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_number_of_sides(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_sides_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_sides_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_sides(&mut self) -> core::ffi::c_int; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_generate_polygon(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_polygon(&mut self) -> core::ffi::c_int; + fn generate_polygon_on(&mut self) -> (); + fn generate_polygon_off(&mut self) -> (); + fn set_generate_polyline(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_polyline(&mut self) -> core::ffi::c_int; + fn generate_polyline_on(&mut self) -> (); + fn generate_polyline_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkSelectionSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn add_id(&mut self, piece: core::ffi::c_longlong, id: core::ffi::c_longlong) -> (); + fn add_string_id(&mut self, piece: core::ffi::c_longlong, id: &str) -> (); + fn add_location( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> (); + fn add_threshold( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> (); + fn add_block(&mut self, blockno: core::ffi::c_longlong) -> (); + fn add_block_selector(&mut self, selector: &str) -> (); + fn remove_all_block_selectors(&mut self) -> (); + fn remove_all_i_ds(&mut self) -> (); + fn remove_all_string_i_ds(&mut self) -> (); + fn remove_all_thresholds(&mut self) -> (); + fn remove_all_locations(&mut self) -> (); + fn remove_all_blocks(&mut self) -> (); + fn set_content_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_content_type(&mut self) -> core::ffi::c_int; + fn set_field_type(&mut self, _arg: core::ffi::c_int) -> (); + fn get_field_type(&mut self) -> core::ffi::c_int; + fn set_containing_cells(&mut self, _arg: core::ffi::c_int) -> (); + fn get_containing_cells(&mut self) -> core::ffi::c_int; + fn set_number_of_layers(&mut self, _arg: core::ffi::c_int) -> (); + fn get_number_of_layers_min_value(&mut self) -> core::ffi::c_int; + fn get_number_of_layers_max_value(&mut self) -> core::ffi::c_int; + fn get_number_of_layers(&mut self) -> core::ffi::c_int; + fn set_inverse(&mut self, _arg: core::ffi::c_int) -> (); + fn get_inverse(&mut self) -> core::ffi::c_int; + fn set_array_name(&mut self, _arg: &str) -> (); + fn set_array_component(&mut self, _arg: core::ffi::c_int) -> (); + fn get_array_component(&mut self) -> core::ffi::c_int; + fn set_composite_index(&mut self, _arg: core::ffi::c_int) -> (); + fn get_composite_index(&mut self) -> core::ffi::c_int; + fn set_hierarchical_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_hierarchical_level(&mut self) -> core::ffi::c_int; + fn set_hierarchical_index(&mut self, _arg: core::ffi::c_int) -> (); + fn get_hierarchical_index(&mut self) -> core::ffi::c_int; + fn set_assembly_name(&mut self, _arg: &str) -> (); + fn add_selector(&mut self, selector: &str) -> (); + fn remove_all_selectors(&mut self) -> (); + fn set_query_string(&mut self, _arg: &str) -> (); +} +pub trait VtkSphereSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution(&mut self) -> core::ffi::c_int; + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution(&mut self) -> core::ffi::c_int; + fn set_start_theta(&mut self, _arg: core::ffi::c_double) -> (); + fn get_start_theta_min_value(&mut self) -> core::ffi::c_double; + fn get_start_theta_max_value(&mut self) -> core::ffi::c_double; + fn get_start_theta(&mut self) -> core::ffi::c_double; + fn set_end_theta(&mut self, _arg: core::ffi::c_double) -> (); + fn get_end_theta_min_value(&mut self) -> core::ffi::c_double; + fn get_end_theta_max_value(&mut self) -> core::ffi::c_double; + fn get_end_theta(&mut self) -> core::ffi::c_double; + fn set_start_phi(&mut self, _arg: core::ffi::c_double) -> (); + fn get_start_phi_min_value(&mut self) -> core::ffi::c_double; + fn get_start_phi_max_value(&mut self) -> core::ffi::c_double; + fn get_start_phi(&mut self) -> core::ffi::c_double; + fn set_end_phi(&mut self, _arg: core::ffi::c_double) -> (); + fn get_end_phi_min_value(&mut self) -> core::ffi::c_double; + fn get_end_phi_max_value(&mut self) -> core::ffi::c_double; + fn get_end_phi(&mut self) -> core::ffi::c_double; + fn set_lat_long_tessellation(&mut self, _arg: core::ffi::c_int) -> (); + fn get_lat_long_tessellation(&mut self) -> core::ffi::c_int; + fn lat_long_tessellation_on(&mut self) -> (); + fn lat_long_tessellation_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; + fn set_generate_normals(&mut self, _arg: core::ffi::c_int) -> (); + fn get_generate_normals(&mut self) -> core::ffi::c_int; + fn generate_normals_on(&mut self) -> (); + fn generate_normals_off(&mut self) -> (); +} +pub trait VtkSuperquadricSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn get_theta_resolution(&mut self) -> core::ffi::c_int; + fn set_theta_resolution(&mut self, i: core::ffi::c_int) -> (); + fn get_phi_resolution(&mut self) -> core::ffi::c_int; + fn set_phi_resolution(&mut self, i: core::ffi::c_int) -> (); + fn get_thickness(&mut self) -> core::ffi::c_double; + fn set_thickness(&mut self, _arg: core::ffi::c_double) -> (); + fn get_thickness_min_value(&mut self) -> core::ffi::c_double; + fn get_thickness_max_value(&mut self) -> core::ffi::c_double; + fn get_phi_roundness(&mut self) -> core::ffi::c_double; + fn set_phi_roundness(&mut self, e: core::ffi::c_double) -> (); + fn get_theta_roundness(&mut self) -> core::ffi::c_double; + fn set_theta_roundness(&mut self, e: core::ffi::c_double) -> (); + fn set_size(&mut self, _arg: core::ffi::c_double) -> (); + fn get_size(&mut self) -> core::ffi::c_double; + fn set_axis_of_symmetry(&mut self, _arg: core::ffi::c_int) -> (); + fn get_axis_of_symmetry(&mut self) -> core::ffi::c_int; + fn set_x_axis_of_symmetry(&mut self) -> (); + fn set_y_axis_of_symmetry(&mut self) -> (); + fn set_z_axis_of_symmetry(&mut self) -> (); + fn toroidal_on(&mut self) -> (); + fn toroidal_off(&mut self) -> (); + fn get_toroidal(&mut self) -> core::ffi::c_int; + fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkTessellatedBoxSource { + fn new(&mut self) -> *mut core::ffi::c_void; + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn set_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> (); + fn set_level(&mut self, _arg: core::ffi::c_int) -> (); + fn get_level(&mut self) -> core::ffi::c_int; + fn set_duplicate_shared_points(&mut self, _arg: core::ffi::c_int) -> (); + fn get_duplicate_shared_points(&mut self) -> core::ffi::c_int; + fn duplicate_shared_points_on(&mut self) -> (); + fn duplicate_shared_points_off(&mut self) -> (); + fn set_quads(&mut self, _arg: core::ffi::c_int) -> (); + fn get_quads(&mut self) -> core::ffi::c_int; + fn quads_on(&mut self) -> (); + fn quads_off(&mut self) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkTextSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_text(&mut self, _arg: &str) -> (); + fn set_backing(&mut self, _arg: core::ffi::c_int) -> (); + fn get_backing(&mut self) -> core::ffi::c_int; + fn backing_on(&mut self) -> (); + fn backing_off(&mut self) -> (); + fn set_foreground_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_background_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> (); + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkTexturedSphereSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; + fn set_radius(&mut self, _arg: core::ffi::c_double) -> (); + fn get_radius_min_value(&mut self) -> core::ffi::c_double; + fn get_radius_max_value(&mut self) -> core::ffi::c_double; + fn get_radius(&mut self) -> core::ffi::c_double; + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_theta_resolution(&mut self) -> core::ffi::c_int; + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> (); + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int; + fn get_phi_resolution(&mut self) -> core::ffi::c_int; + fn set_theta(&mut self, _arg: core::ffi::c_double) -> (); + fn get_theta_min_value(&mut self) -> core::ffi::c_double; + fn get_theta_max_value(&mut self) -> core::ffi::c_double; + fn get_theta(&mut self) -> core::ffi::c_double; + fn set_phi(&mut self, _arg: core::ffi::c_double) -> (); + fn get_phi_min_value(&mut self) -> core::ffi::c_double; + fn get_phi_max_value(&mut self) -> core::ffi::c_double; + fn get_phi(&mut self) -> core::ffi::c_double; + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> (); + fn get_output_points_precision(&mut self) -> core::ffi::c_int; +} +pub trait VtkUniformHyperTreeGridSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void; + fn new_instance(&mut self) -> *mut core::ffi::c_void; + fn new(&mut self) -> *mut core::ffi::c_void; +} +impl VtkArcSource for vtkArcSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arc_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arc_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arc_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arc_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arc_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arc_source_new_instance(self.0) } + } + fn set_point_1( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_point_1( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_point_1(self.0, _arg1, _arg2, _arg3) } + } + fn set_point_2( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_point_2( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_point_2(self.0, _arg1, _arg2, _arg3) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_polar_vector( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_polar_vector( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_polar_vector(self.0, _arg1, _arg2, _arg3) } + } + fn set_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_arc_source_set_angle(self.0, _arg) } + } + fn get_angle_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arc_source_get_angle_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arc_source_get_angle_min_value(self.0) } + } + fn get_angle_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arc_source_get_angle_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arc_source_get_angle_max_value(self.0) } + } + fn get_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arc_source_get_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arc_source_get_angle(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_arc_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arc_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arc_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arc_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arc_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arc_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arc_source_get_resolution(self.0) } + } + fn set_negative(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_negative(sself: *mut core::ffi::c_void, _arg: bool); + } + unsafe { vtk_arc_source_set_negative(self.0, _arg) } + } + fn get_negative(&mut self) -> bool { + unsafe extern "C" { + fn vtk_arc_source_get_negative(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_arc_source_get_negative(self.0) } + } + fn negative_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_arc_source_negative_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arc_source_negative_on(self.0) } + } + fn negative_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_arc_source_negative_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arc_source_negative_off(self.0) } + } + fn set_use_normal_and_angle(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_use_normal_and_angle( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_arc_source_set_use_normal_and_angle(self.0, _arg) } + } + fn get_use_normal_and_angle(&mut self) -> bool { + unsafe extern "C" { + fn vtk_arc_source_get_use_normal_and_angle( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_arc_source_get_use_normal_and_angle(self.0) } + } + fn use_normal_and_angle_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_arc_source_use_normal_and_angle_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arc_source_use_normal_and_angle_on(self.0) } + } + fn use_normal_and_angle_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_arc_source_use_normal_and_angle_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arc_source_use_normal_and_angle_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_arc_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_arc_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arc_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arc_source_get_output_points_precision(self.0) } + } +} +impl VtkArrowSource for vtkArrowSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arrow_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arrow_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arrow_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arrow_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_arrow_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_arrow_source_new_instance(self.0) } + } + fn set_tip_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_tip_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_arrow_source_set_tip_length(self.0, _arg) } + } + fn get_tip_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_length_min_value(self.0) } + } + fn get_tip_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_length_max_value(self.0) } + } + fn get_tip_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_length(self.0) } + } + fn set_tip_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_tip_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_arrow_source_set_tip_radius(self.0, _arg) } + } + fn get_tip_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_radius_min_value(self.0) } + } + fn get_tip_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_radius_max_value(self.0) } + } + fn get_tip_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_tip_radius(self.0) } + } + fn set_tip_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_tip_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_arrow_source_set_tip_resolution(self.0, _arg) } + } + fn get_tip_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_tip_resolution_min_value(self.0) } + } + fn get_tip_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_tip_resolution_max_value(self.0) } + } + fn get_tip_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_tip_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_tip_resolution(self.0) } + } + fn set_shaft_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_shaft_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_arrow_source_set_shaft_radius(self.0, _arg) } + } + fn get_shaft_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_shaft_radius_min_value(self.0) } + } + fn get_shaft_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_shaft_radius_max_value(self.0) } + } + fn get_shaft_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_arrow_source_get_shaft_radius(self.0) } + } + fn set_shaft_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_shaft_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_arrow_source_set_shaft_resolution(self.0, _arg) } + } + fn get_shaft_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_shaft_resolution_min_value(self.0) } + } + fn get_shaft_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_shaft_resolution_max_value(self.0) } + } + fn get_shaft_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_arrow_source_get_shaft_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_arrow_source_get_shaft_resolution(self.0) } + } + fn invert_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_arrow_source_invert_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arrow_source_invert_on(self.0) } + } + fn invert_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_arrow_source_invert_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_arrow_source_invert_off(self.0) } + } + fn set_invert(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_invert(sself: *mut core::ffi::c_void, _arg: bool); + } + unsafe { vtk_arrow_source_set_invert(self.0, _arg) } + } + fn get_invert(&mut self) -> bool { + unsafe extern "C" { + fn vtk_arrow_source_get_invert(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_arrow_source_get_invert(self.0) } + } + fn set_arrow_origin_to_default(&mut self) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_arrow_origin_to_default( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_arrow_source_set_arrow_origin_to_default(self.0) } + } + fn set_arrow_origin_to_center(&mut self) -> () { + unsafe extern "C" { + fn vtk_arrow_source_set_arrow_origin_to_center( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_arrow_source_set_arrow_origin_to_center(self.0) } + } +} +impl VtkCapsuleSource for vtkCapsuleSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_capsule_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_capsule_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_capsule_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_capsule_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_capsule_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_capsule_source_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_capsule_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_capsule_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_cylinder_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_cylinder_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_capsule_source_set_cylinder_length(self.0, _arg) } + } + fn get_cylinder_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_cylinder_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_cylinder_length_min_value(self.0) } + } + fn get_cylinder_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_cylinder_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_cylinder_length_max_value(self.0) } + } + fn get_cylinder_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_capsule_source_get_cylinder_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_capsule_source_get_cylinder_length(self.0) } + } + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_theta_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_capsule_source_set_theta_resolution(self.0, _arg) } + } + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_theta_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_theta_resolution_min_value(self.0) } + } + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_theta_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_theta_resolution_max_value(self.0) } + } + fn get_theta_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_theta_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_theta_resolution(self.0) } + } + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_phi_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_capsule_source_set_phi_resolution(self.0, _arg) } + } + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_phi_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_phi_resolution_min_value(self.0) } + } + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_phi_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_phi_resolution_max_value(self.0) } + } + fn get_phi_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_phi_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_phi_resolution(self.0) } + } + fn set_lat_long_tessellation(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_lat_long_tessellation( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_capsule_source_set_lat_long_tessellation(self.0, _arg) } + } + fn get_lat_long_tessellation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_lat_long_tessellation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_lat_long_tessellation(self.0) } + } + fn lat_long_tessellation_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_capsule_source_lat_long_tessellation_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_capsule_source_lat_long_tessellation_on(self.0) } + } + fn lat_long_tessellation_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_capsule_source_lat_long_tessellation_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_capsule_source_lat_long_tessellation_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_capsule_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_capsule_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_capsule_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_capsule_source_get_output_points_precision(self.0) } + } +} +impl VtkCellTypeSource for vtkCellTypeSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_type_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_type_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_type_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_type_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cell_type_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cell_type_source_new_instance(self.0) } + } + fn set_cell_type(&mut self, cellType: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_cell_type( + sself: *mut core::ffi::c_void, + cellType: core::ffi::c_int, + ); + } + unsafe { vtk_cell_type_source_set_cell_type(self.0, cellType) } + } + fn get_cell_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_cell_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_cell_type(self.0) } + } + fn set_cell_order(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_cell_order( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cell_type_source_set_cell_order(self.0, _arg) } + } + fn get_cell_order(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_cell_order( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_cell_order(self.0) } + } + fn set_complete_quadratic_simplicial_elements(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_complete_quadratic_simplicial_elements( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { + vtk_cell_type_source_set_complete_quadratic_simplicial_elements(self.0, _arg) + } + } + fn get_complete_quadratic_simplicial_elements(&mut self) -> bool { + unsafe extern "C" { + fn vtk_cell_type_source_get_complete_quadratic_simplicial_elements( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { + vtk_cell_type_source_get_complete_quadratic_simplicial_elements(self.0) + } + } + fn complete_quadratic_simplicial_elements_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_complete_quadratic_simplicial_elements_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_cell_type_source_complete_quadratic_simplicial_elements_on(self.0) } + } + fn complete_quadratic_simplicial_elements_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_complete_quadratic_simplicial_elements_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_cell_type_source_complete_quadratic_simplicial_elements_off(self.0) + } + } + fn set_polynomial_field_order(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_polynomial_field_order( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cell_type_source_set_polynomial_field_order(self.0, _arg) } + } + fn get_polynomial_field_order_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_polynomial_field_order_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_polynomial_field_order_min_value(self.0) } + } + fn get_polynomial_field_order_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_polynomial_field_order_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_polynomial_field_order_max_value(self.0) } + } + fn get_polynomial_field_order(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_polynomial_field_order( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_polynomial_field_order(self.0) } + } + fn get_cell_dimension(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_cell_dimension( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_cell_dimension(self.0) } + } + fn set_output_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cell_type_source_set_output_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cell_type_source_set_output_precision(self.0, _arg) } + } + fn get_output_precision_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_output_precision_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_output_precision_min_value(self.0) } + } + fn get_output_precision_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_output_precision_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_output_precision_max_value(self.0) } + } + fn get_output_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cell_type_source_get_output_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cell_type_source_get_output_precision(self.0) } + } +} +impl VtkConeSource for vtkConeSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cone_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cone_source_new(self.0) } + } + fn set_height(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_height( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_height(self.0, _arg) } + } + fn get_height_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_height_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_height_min_value(self.0) } + } + fn get_height_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_height_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_height_max_value(self.0) } + } + fn get_height(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_height( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_height(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_radius(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cone_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_resolution(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_direction( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_direction( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_direction(self.0, _arg1, _arg2, _arg3) } + } + fn set_angle(&mut self, angle: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_angle( + sself: *mut core::ffi::c_void, + angle: core::ffi::c_double, + ); + } + unsafe { vtk_cone_source_set_angle(self.0, angle) } + } + fn get_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cone_source_get_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cone_source_get_angle(self.0) } + } + fn set_capping(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_capping( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cone_source_set_capping(self.0, _arg) } + } + fn get_capping(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_capping( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_capping(self.0) } + } + fn capping_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_cone_source_capping_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cone_source_capping_on(self.0) } + } + fn capping_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_cone_source_capping_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cone_source_capping_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cone_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cone_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cone_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cone_source_get_output_points_precision(self.0) } + } +} +impl VtkCubeSource for vtkCubeSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cube_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cube_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cube_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cube_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cube_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cube_source_new_instance(self.0) } + } + fn set_x_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_x_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_x_length(self.0, _arg) } + } + fn get_x_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_x_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_x_length_min_value(self.0) } + } + fn get_x_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_x_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_x_length_max_value(self.0) } + } + fn get_x_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_x_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_x_length(self.0) } + } + fn set_y_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_y_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_y_length(self.0, _arg) } + } + fn get_y_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_y_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_y_length_min_value(self.0) } + } + fn get_y_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_y_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_y_length_max_value(self.0) } + } + fn get_y_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_y_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_y_length(self.0) } + } + fn set_z_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_z_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_z_length(self.0, _arg) } + } + fn get_z_length_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_z_length_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_z_length_min_value(self.0) } + } + fn get_z_length_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_z_length_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_z_length_max_value(self.0) } + } + fn get_z_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cube_source_get_z_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cube_source_get_z_length(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_bounds( + &mut self, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_bounds( + sself: *mut core::ffi::c_void, + xMin: core::ffi::c_double, + xMax: core::ffi::c_double, + yMin: core::ffi::c_double, + yMax: core::ffi::c_double, + zMin: core::ffi::c_double, + zMax: core::ffi::c_double, + ); + } + unsafe { vtk_cube_source_set_bounds(self.0, xMin, xMax, yMin, yMax, zMin, zMax) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cube_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cube_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cube_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cube_source_get_output_points_precision(self.0) } + } +} +impl VtkCylinderSource for vtkCylinderSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_cylinder_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_cylinder_source_new_instance(self.0) } + } + fn set_height(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_height( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_source_set_height(self.0, _arg) } + } + fn get_height_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_height_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_height_min_value(self.0) } + } + fn get_height_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_height_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_height_max_value(self.0) } + } + fn get_height(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_height( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_height(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_cylinder_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_cylinder_source_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_cylinder_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cylinder_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_resolution(self.0) } + } + fn set_capping(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_capping( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cylinder_source_set_capping(self.0, _arg) } + } + fn get_capping(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_capping( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_capping(self.0) } + } + fn capping_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_capping_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cylinder_source_capping_on(self.0) } + } + fn capping_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_capping_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_cylinder_source_capping_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_cylinder_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_cylinder_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_cylinder_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_cylinder_source_get_output_points_precision(self.0) } + } +} +impl VtkDiagonalMatrixSource for vtkDiagonalMatrixSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_diagonal_matrix_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_diagonal_matrix_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_diagonal_matrix_source_new_instance(self.0) } + } + fn get_array_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_array_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_diagonal_matrix_source_get_array_type(self.0) } + } + fn set_array_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_array_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_diagonal_matrix_source_set_array_type(self.0, _arg) } + } + fn get_extents(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_extents( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_diagonal_matrix_source_get_extents(self.0) } + } + fn set_extents(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_extents( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_diagonal_matrix_source_set_extents(self.0, _arg) } + } + fn get_diagonal(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_diagonal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_diagonal_matrix_source_get_diagonal(self.0) } + } + fn set_diagonal(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_diagonal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_diagonal_matrix_source_set_diagonal(self.0, _arg) } + } + fn get_super_diagonal(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_super_diagonal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_diagonal_matrix_source_get_super_diagonal(self.0) } + } + fn set_super_diagonal(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_super_diagonal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_diagonal_matrix_source_set_super_diagonal(self.0, _arg) } + } + fn get_sub_diagonal(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_get_sub_diagonal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_diagonal_matrix_source_get_sub_diagonal(self.0) } + } + fn set_sub_diagonal(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_sub_diagonal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_diagonal_matrix_source_set_sub_diagonal(self.0, _arg) } + } + fn set_row_label(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_row_label( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_diagonal_matrix_source_set_row_label(self.0, c__arg.as_ptr()) } + } + fn set_column_label(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_diagonal_matrix_source_set_column_label( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_diagonal_matrix_source_set_column_label(self.0, c__arg.as_ptr()) } + } +} +impl VtkDiskSource for vtkDiskSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_disk_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_disk_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_disk_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_disk_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_disk_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_disk_source_new_instance(self.0) } + } + fn set_inner_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_inner_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_disk_source_set_inner_radius(self.0, _arg) } + } + fn get_inner_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_inner_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_inner_radius_min_value(self.0) } + } + fn get_inner_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_inner_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_inner_radius_max_value(self.0) } + } + fn get_inner_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_inner_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_inner_radius(self.0) } + } + fn set_outer_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_outer_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_disk_source_set_outer_radius(self.0, _arg) } + } + fn get_outer_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_outer_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_outer_radius_min_value(self.0) } + } + fn get_outer_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_outer_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_outer_radius_max_value(self.0) } + } + fn get_outer_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_disk_source_get_outer_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_disk_source_get_outer_radius(self.0) } + } + fn set_radial_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_radial_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_disk_source_set_radial_resolution(self.0, _arg) } + } + fn get_radial_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_radial_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_radial_resolution_min_value(self.0) } + } + fn get_radial_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_radial_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_radial_resolution_max_value(self.0) } + } + fn get_radial_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_radial_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_radial_resolution(self.0) } + } + fn set_circumferential_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_circumferential_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_disk_source_set_circumferential_resolution(self.0, _arg) } + } + fn get_circumferential_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_circumferential_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_circumferential_resolution_min_value(self.0) } + } + fn get_circumferential_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_circumferential_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_circumferential_resolution_max_value(self.0) } + } + fn get_circumferential_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_circumferential_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_circumferential_resolution(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_disk_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_disk_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_disk_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_disk_source_get_output_points_precision(self.0) } + } +} +impl VtkEllipseArcSource for vtkEllipseArcSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ellipse_arc_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ellipse_arc_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ellipse_arc_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ellipse_arc_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_ellipse_arc_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_ellipse_arc_source_new_instance(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_major_radius_vector( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_major_radius_vector( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { + vtk_ellipse_arc_source_set_major_radius_vector(self.0, _arg1, _arg2, _arg3) + } + } + fn set_start_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_start_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_start_angle(self.0, _arg) } + } + fn get_start_angle_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_start_angle_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_start_angle_min_value(self.0) } + } + fn get_start_angle_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_start_angle_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_start_angle_max_value(self.0) } + } + fn get_start_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_start_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_start_angle(self.0) } + } + fn set_segment_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_segment_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_segment_angle(self.0, _arg) } + } + fn get_segment_angle_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_segment_angle_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_segment_angle_min_value(self.0) } + } + fn get_segment_angle_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_segment_angle_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_segment_angle_max_value(self.0) } + } + fn get_segment_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_segment_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_segment_angle(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ellipse_arc_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ellipse_arc_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ellipse_arc_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ellipse_arc_source_get_resolution(self.0) } + } + fn set_close(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_close( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_ellipse_arc_source_set_close(self.0, _arg) } + } + fn get_close(&mut self) -> bool { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_close(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_ellipse_arc_source_get_close(self.0) } + } + fn close_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_close_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ellipse_arc_source_close_on(self.0) } + } + fn close_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_close_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_ellipse_arc_source_close_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_ellipse_arc_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_ellipse_arc_source_get_output_points_precision(self.0) } + } + fn set_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_ellipse_arc_source_set_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_ellipse_arc_source_set_ratio(self.0, _arg) } + } + fn get_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_ratio_min_value(self.0) } + } + fn get_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_ratio_max_value(self.0) } + } + fn get_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_ellipse_arc_source_get_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_ellipse_arc_source_get_ratio(self.0) } + } +} +impl VtkEllipticalButtonSource for vtkEllipticalButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_elliptical_button_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_elliptical_button_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_elliptical_button_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_elliptical_button_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_elliptical_button_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_elliptical_button_source_new(self.0) } + } + fn set_width(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_width( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_elliptical_button_source_set_width(self.0, _arg) } + } + fn get_width_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_width_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_width_min_value(self.0) } + } + fn get_width_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_width_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_width_max_value(self.0) } + } + fn get_width(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_width( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_width(self.0) } + } + fn set_height(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_height( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_elliptical_button_source_set_height(self.0, _arg) } + } + fn get_height_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_height_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_height_min_value(self.0) } + } + fn get_height_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_height_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_height_max_value(self.0) } + } + fn get_height(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_height( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_height(self.0) } + } + fn set_depth(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_depth( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_elliptical_button_source_set_depth(self.0, _arg) } + } + fn get_depth_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_depth_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_depth_min_value(self.0) } + } + fn get_depth_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_depth_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_depth_max_value(self.0) } + } + fn get_depth(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_depth( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_depth(self.0) } + } + fn set_circumferential_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_circumferential_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_elliptical_button_source_set_circumferential_resolution(self.0, _arg) + } + } + fn get_circumferential_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_circumferential_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_elliptical_button_source_get_circumferential_resolution_min_value(self.0) + } + } + fn get_circumferential_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_circumferential_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_elliptical_button_source_get_circumferential_resolution_max_value(self.0) + } + } + fn get_circumferential_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_circumferential_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_circumferential_resolution(self.0) } + } + fn set_texture_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_texture_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_elliptical_button_source_set_texture_resolution(self.0, _arg) } + } + fn get_texture_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_texture_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_texture_resolution_min_value(self.0) } + } + fn get_texture_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_texture_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_texture_resolution_max_value(self.0) } + } + fn get_texture_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_texture_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_texture_resolution(self.0) } + } + fn set_shoulder_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_shoulder_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_elliptical_button_source_set_shoulder_resolution(self.0, _arg) } + } + fn get_shoulder_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_shoulder_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_shoulder_resolution_min_value(self.0) } + } + fn get_shoulder_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_shoulder_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_shoulder_resolution_max_value(self.0) } + } + fn get_shoulder_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_shoulder_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_shoulder_resolution(self.0) } + } + fn set_radial_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_radial_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_elliptical_button_source_set_radial_ratio(self.0, _arg) } + } + fn get_radial_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_radial_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_radial_ratio_min_value(self.0) } + } + fn get_radial_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_radial_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_radial_ratio_max_value(self.0) } + } + fn get_radial_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_radial_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_elliptical_button_source_get_radial_ratio(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_elliptical_button_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_elliptical_button_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_elliptical_button_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_elliptical_button_source_get_output_points_precision(self.0) } + } +} +impl VtkFrustumSource for vtkFrustumSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_frustum_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_frustum_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_frustum_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_frustum_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_frustum_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_frustum_source_new_instance(self.0) } + } + fn get_planes(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_frustum_source_get_planes( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_frustum_source_get_planes(self.0) } + } + fn set_planes(&mut self, planes: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_frustum_source_set_planes( + sself: *mut core::ffi::c_void, + planes: *mut core::ffi::c_void, + ); + } + unsafe { vtk_frustum_source_set_planes(self.0, planes) } + } + fn get_show_lines(&mut self) -> bool { + unsafe extern "C" { + fn vtk_frustum_source_get_show_lines(sself: *mut core::ffi::c_void) -> bool; + } + unsafe { vtk_frustum_source_get_show_lines(self.0) } + } + fn set_show_lines(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_frustum_source_set_show_lines( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_frustum_source_set_show_lines(self.0, _arg) } + } + fn show_lines_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_frustum_source_show_lines_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_frustum_source_show_lines_on(self.0) } + } + fn show_lines_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_frustum_source_show_lines_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_frustum_source_show_lines_off(self.0) } + } + fn get_lines_length(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_frustum_source_get_lines_length( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_frustum_source_get_lines_length(self.0) } + } + fn set_lines_length(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_frustum_source_set_lines_length( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_frustum_source_set_lines_length(self.0, _arg) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_frustum_source_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_frustum_source_get_m_time(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_frustum_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_frustum_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_frustum_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_frustum_source_get_output_points_precision(self.0) } + } +} +impl VtkGlyphSource2D for vtkGlyphSource2D { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_glyph_source_2_d_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_glyph_source_2_d_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_glyph_source_2_d_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_glyph_source_2_d_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_glyph_source_2_d_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_glyph_source_2_d_new(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_scale(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_scale( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_scale(self.0, _arg) } + } + fn get_scale_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_min_value(self.0) } + } + fn get_scale_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_max_value(self.0) } + } + fn get_scale(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale(self.0) } + } + fn set_scale_2(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_scale_2( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_scale_2(self.0, _arg) } + } + fn get_scale_2_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_2_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_2_min_value(self.0) } + } + fn get_scale_2_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_2_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_2_max_value(self.0) } + } + fn get_scale_2(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_scale_2( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_scale_2(self.0) } + } + fn set_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_color(self.0, _arg1, _arg2, _arg3) } + } + fn set_filled(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_filled( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_filled(self.0, _arg) } + } + fn get_filled(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_filled( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_filled(self.0) } + } + fn filled_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_filled_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_filled_on(self.0) } + } + fn filled_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_filled_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_filled_off(self.0) } + } + fn set_dash(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_dash( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_dash(self.0, _arg) } + } + fn get_dash(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_dash( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_dash(self.0) } + } + fn dash_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_dash_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_dash_on(self.0) } + } + fn dash_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_dash_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_dash_off(self.0) } + } + fn set_cross(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_cross( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_cross(self.0, _arg) } + } + fn get_cross(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_cross( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_cross(self.0) } + } + fn cross_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_cross_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_cross_on(self.0) } + } + fn cross_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_cross_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_glyph_source_2_d_cross_off(self.0) } + } + fn set_rotation_angle(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_rotation_angle( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_glyph_source_2_d_set_rotation_angle(self.0, _arg) } + } + fn get_rotation_angle(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_rotation_angle( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_glyph_source_2_d_get_rotation_angle(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_resolution(self.0) } + } + fn set_glyph_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type(self.0, _arg) } + } + fn get_glyph_type_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_glyph_type_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_glyph_type_min_value(self.0) } + } + fn get_glyph_type_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_glyph_type_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_glyph_type_max_value(self.0) } + } + fn get_glyph_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_glyph_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_glyph_type(self.0) } + } + fn set_glyph_type_to_none(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_none( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_none(self.0) } + } + fn set_glyph_type_to_vertex(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_vertex( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_vertex(self.0) } + } + fn set_glyph_type_to_dash(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_dash( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_dash(self.0) } + } + fn set_glyph_type_to_cross(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_cross( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_cross(self.0) } + } + fn set_glyph_type_to_thick_cross(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_thick_cross( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_thick_cross(self.0) } + } + fn set_glyph_type_to_triangle(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_triangle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_triangle(self.0) } + } + fn set_glyph_type_to_square(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_square( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_square(self.0) } + } + fn set_glyph_type_to_circle(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_circle( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_circle(self.0) } + } + fn set_glyph_type_to_diamond(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_diamond( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_diamond(self.0) } + } + fn set_glyph_type_to_arrow(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_arrow( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_arrow(self.0) } + } + fn set_glyph_type_to_thick_arrow(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_thick_arrow( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_thick_arrow(self.0) } + } + fn set_glyph_type_to_hooked_arrow(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_hooked_arrow( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_hooked_arrow(self.0) } + } + fn set_glyph_type_to_edge_arrow(&mut self) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_glyph_type_to_edge_arrow( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_glyph_source_2_d_set_glyph_type_to_edge_arrow(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_glyph_source_2_d_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_glyph_source_2_d_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_glyph_source_2_d_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_glyph_source_2_d_get_output_points_precision(self.0) } + } +} +impl VtkGraphToPolyData for vtkGraphToPolyData { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_to_poly_data_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_to_poly_data_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_to_poly_data_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_to_poly_data_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_graph_to_poly_data_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_graph_to_poly_data_new_instance(self.0) } + } + fn set_edge_glyph_output(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_graph_to_poly_data_set_edge_glyph_output( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_graph_to_poly_data_set_edge_glyph_output(self.0, _arg) } + } + fn get_edge_glyph_output(&mut self) -> bool { + unsafe extern "C" { + fn vtk_graph_to_poly_data_get_edge_glyph_output( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_graph_to_poly_data_get_edge_glyph_output(self.0) } + } + fn edge_glyph_output_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_graph_to_poly_data_edge_glyph_output_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_graph_to_poly_data_edge_glyph_output_on(self.0) } + } + fn edge_glyph_output_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_graph_to_poly_data_edge_glyph_output_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_graph_to_poly_data_edge_glyph_output_off(self.0) } + } + fn set_edge_glyph_position(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_graph_to_poly_data_set_edge_glyph_position( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_graph_to_poly_data_set_edge_glyph_position(self.0, _arg) } + } + fn get_edge_glyph_position(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_graph_to_poly_data_get_edge_glyph_position( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_graph_to_poly_data_get_edge_glyph_position(self.0) } + } +} +impl VtkHyperTreeGridSource for vtkHyperTreeGridSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_new(self.0) } + } + fn get_maximum_level(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_maximum_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_maximum_level(self.0) } + } + fn set_maximum_level(&mut self, levels: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_maximum_level( + sself: *mut core::ffi::c_void, + levels: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_maximum_level(self.0, levels) } + } + fn get_max_depth(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_max_depth( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_max_depth(self.0) } + } + fn set_max_depth(&mut self, levels: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_max_depth( + sself: *mut core::ffi::c_void, + levels: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_max_depth(self.0, levels) } + } + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_origin(self.0, _arg1, _arg2, _arg3) } + } + fn set_grid_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_grid_scale( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_grid_scale(self.0, _arg1, _arg2, _arg3) } + } + fn set_transposed_root_indexing(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_transposed_root_indexing( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_transposed_root_indexing(self.0, _arg) } + } + fn get_transposed_root_indexing(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_transposed_root_indexing( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_source_get_transposed_root_indexing(self.0) } + } + fn set_indexing_mode_to_kji(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_indexing_mode_to_kji( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_indexing_mode_to_kji(self.0) } + } + fn set_indexing_mode_to_ijk(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_indexing_mode_to_ijk( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_indexing_mode_to_ijk(self.0) } + } + fn get_orientation(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_orientation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_orientation(self.0) } + } + fn set_branch_factor(&mut self, _arg: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_branch_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uint, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_branch_factor(self.0, _arg) } + } + fn get_branch_factor_min_value(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_branch_factor_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_branch_factor_min_value(self.0) } + } + fn get_branch_factor_max_value(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_branch_factor_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_branch_factor_max_value(self.0) } + } + fn get_branch_factor(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_branch_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_hyper_tree_grid_source_get_branch_factor(self.0) } + } + fn set_use_descriptor(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_use_descriptor( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_use_descriptor(self.0, _arg) } + } + fn get_use_descriptor(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_use_descriptor( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_source_get_use_descriptor(self.0) } + } + fn use_descriptor_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_use_descriptor_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_use_descriptor_on(self.0) } + } + fn use_descriptor_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_use_descriptor_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_use_descriptor_off(self.0) } + } + fn set_use_mask(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_use_mask( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_use_mask(self.0, _arg) } + } + fn get_use_mask(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_use_mask( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_source_get_use_mask(self.0) } + } + fn use_mask_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_use_mask_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_source_use_mask_on(self.0) } + } + fn use_mask_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_use_mask_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_hyper_tree_grid_source_use_mask_off(self.0) } + } + fn set_generate_interface_fields(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_generate_interface_fields( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_generate_interface_fields(self.0, _arg) } + } + fn get_generate_interface_fields(&mut self) -> bool { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_generate_interface_fields( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_hyper_tree_grid_source_get_generate_interface_fields(self.0) } + } + fn generate_interface_fields_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_generate_interface_fields_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_generate_interface_fields_on(self.0) } + } + fn generate_interface_fields_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_generate_interface_fields_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_generate_interface_fields_off(self.0) } + } + fn set_descriptor(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_descriptor( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_descriptor(self.0, c__arg.as_ptr()) } + } + fn set_mask(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_mask( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_mask(self.0, c__arg.as_ptr()) } + } + fn set_descriptor_bits(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_descriptor_bits( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_descriptor_bits(self.0, p0) } + } + fn get_descriptor_bits(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_descriptor_bits( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_get_descriptor_bits(self.0) } + } + fn set_level_zero_material_index(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_level_zero_material_index( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_level_zero_material_index(self.0, p0) } + } + fn set_mask_bits(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_mask_bits( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_mask_bits(self.0, p0) } + } + fn get_mask_bits(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_mask_bits( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_get_mask_bits(self.0) } + } + fn set_quadric(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_set_quadric( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_hyper_tree_grid_source_set_quadric(self.0, p0) } + } + fn get_quadric(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_quadric( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_hyper_tree_grid_source_get_quadric(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_hyper_tree_grid_source_get_m_time(self.0) } + } + fn convert_descriptor_string_to_bit_array( + &mut self, + p0: &str, + ) -> *mut core::ffi::c_void { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_convert_descriptor_string_to_bit_array( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_source_convert_descriptor_string_to_bit_array( + self.0, + c_p0.as_ptr(), + ) + } + } + fn convert_mask_string_to_bit_array(&mut self, p0: &str) -> *mut core::ffi::c_void { + let c_p0 = std::ffi::CString::new(p0).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_hyper_tree_grid_source_convert_mask_string_to_bit_array( + sself: *mut core::ffi::c_void, + p0: *const core::ffi::c_char, + ) -> *mut core::ffi::c_void; + } + unsafe { + vtk_hyper_tree_grid_source_convert_mask_string_to_bit_array( + self.0, + c_p0.as_ptr(), + ) + } + } +} +impl VtkLineSource for vtkLineSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_source_new_instance(self.0) } + } + fn set_point_1( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_source_set_point_1( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_line_source_set_point_1(self.0, _arg1, _arg2, _arg3) } + } + fn set_point_2( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_source_set_point_2( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_line_source_set_point_2(self.0, _arg1, _arg2, _arg3) } + } + fn set_use_regular_refinement(&mut self, _arg: bool) -> () { + unsafe extern "C" { + fn vtk_line_source_set_use_regular_refinement( + sself: *mut core::ffi::c_void, + _arg: bool, + ); + } + unsafe { vtk_line_source_set_use_regular_refinement(self.0, _arg) } + } + fn get_use_regular_refinement(&mut self) -> bool { + unsafe extern "C" { + fn vtk_line_source_get_use_regular_refinement( + sself: *mut core::ffi::c_void, + ) -> bool; + } + unsafe { vtk_line_source_get_use_regular_refinement(self.0) } + } + fn use_regular_refinement_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_line_source_use_regular_refinement_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_line_source_use_regular_refinement_on(self.0) } + } + fn use_regular_refinement_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_line_source_use_regular_refinement_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_line_source_use_regular_refinement_off(self.0) } + } + fn set_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_line_source_set_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_line_source_set_resolution(self.0, _arg) } + } + fn get_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_resolution_min_value(self.0) } + } + fn get_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_resolution_max_value(self.0) } + } + fn get_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_resolution(self.0) } + } + fn set_number_of_refinement_ratios(&mut self, p0: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_line_source_set_number_of_refinement_ratios( + sself: *mut core::ffi::c_void, + p0: core::ffi::c_int, + ); + } + unsafe { vtk_line_source_set_number_of_refinement_ratios(self.0, p0) } + } + fn set_refinement_ratio( + &mut self, + index: core::ffi::c_int, + value: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_line_source_set_refinement_ratio( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + value: core::ffi::c_double, + ); + } + unsafe { vtk_line_source_set_refinement_ratio(self.0, index, value) } + } + fn get_number_of_refinement_ratios(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_number_of_refinement_ratios( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_number_of_refinement_ratios(self.0) } + } + fn get_refinement_ratio(&mut self, index: core::ffi::c_int) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_line_source_get_refinement_ratio( + sself: *mut core::ffi::c_void, + index: core::ffi::c_int, + ) -> core::ffi::c_double; + } + unsafe { vtk_line_source_get_refinement_ratio(self.0, index) } + } + fn set_points(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_line_source_set_points( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_line_source_set_points(self.0, p0) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_line_source_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_line_source_get_points(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_line_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_line_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_line_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_line_source_get_output_points_precision(self.0) } + } +} +impl VtkOutlineCornerFilter for vtkOutlineCornerFilter { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_filter_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_filter_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_filter_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_filter_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_filter_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_filter_new(self.0) } + } + fn set_corner_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_outline_corner_filter_set_corner_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_outline_corner_filter_set_corner_factor(self.0, _arg) } + } + fn get_corner_factor_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_filter_get_corner_factor_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_filter_get_corner_factor_min_value(self.0) } + } + fn get_corner_factor_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_filter_get_corner_factor_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_filter_get_corner_factor_max_value(self.0) } + } + fn get_corner_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_filter_get_corner_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_filter_get_corner_factor(self.0) } + } +} +impl VtkOutlineCornerSource for vtkOutlineCornerSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_corner_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_corner_source_new(self.0) } + } + fn set_corner_factor(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_outline_corner_source_set_corner_factor( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_outline_corner_source_set_corner_factor(self.0, _arg) } + } + fn get_corner_factor_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_source_get_corner_factor_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_source_get_corner_factor_min_value(self.0) } + } + fn get_corner_factor_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_source_get_corner_factor_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_source_get_corner_factor_max_value(self.0) } + } + fn get_corner_factor(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_outline_corner_source_get_corner_factor( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_outline_corner_source_get_corner_factor(self.0) } + } +} +impl VtkOutlineSource for vtkOutlineSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_outline_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_outline_source_new_instance(self.0) } + } + fn set_box_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_box_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_outline_source_set_box_type(self.0, _arg) } + } + fn get_box_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_outline_source_get_box_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_outline_source_get_box_type(self.0) } + } + fn set_box_type_to_axis_aligned(&mut self) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_box_type_to_axis_aligned( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_outline_source_set_box_type_to_axis_aligned(self.0) } + } + fn set_box_type_to_oriented(&mut self) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_box_type_to_oriented( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_outline_source_set_box_type_to_oriented(self.0) } + } + fn set_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_bounds( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ); + } + unsafe { + vtk_outline_source_set_bounds( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_generate_faces(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_generate_faces( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_outline_source_set_generate_faces(self.0, _arg) } + } + fn generate_faces_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_outline_source_generate_faces_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_outline_source_generate_faces_on(self.0) } + } + fn generate_faces_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_outline_source_generate_faces_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_outline_source_generate_faces_off(self.0) } + } + fn get_generate_faces(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_outline_source_get_generate_faces( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_outline_source_get_generate_faces(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_outline_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_outline_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_outline_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_outline_source_get_output_points_precision(self.0) } + } +} +impl VtkParametricFunctionSource for vtkParametricFunctionSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_function_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_function_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_function_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_function_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_function_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_function_source_new(self.0) } + } + fn set_parametric_function(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_parametric_function( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_parametric_function(self.0, p0) } + } + fn get_parametric_function(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_parametric_function_source_get_parametric_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_parametric_function_source_get_parametric_function(self.0) } + } + fn set_u_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_u_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_u_resolution(self.0, _arg) } + } + fn get_u_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_u_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_u_resolution_min_value(self.0) } + } + fn get_u_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_u_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_u_resolution_max_value(self.0) } + } + fn get_u_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_u_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_u_resolution(self.0) } + } + fn set_v_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_v_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_v_resolution(self.0, _arg) } + } + fn get_v_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_v_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_v_resolution_min_value(self.0) } + } + fn get_v_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_v_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_v_resolution_max_value(self.0) } + } + fn get_v_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_v_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_v_resolution(self.0) } + } + fn set_w_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_w_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_w_resolution(self.0, _arg) } + } + fn get_w_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_w_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_w_resolution_min_value(self.0) } + } + fn get_w_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_w_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_w_resolution_max_value(self.0) } + } + fn get_w_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_w_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_w_resolution(self.0) } + } + fn generate_texture_coordinates_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_generate_texture_coordinates_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_generate_texture_coordinates_on(self.0) } + } + fn generate_texture_coordinates_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_generate_texture_coordinates_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_parametric_function_source_generate_texture_coordinates_off(self.0) + } + } + fn set_generate_texture_coordinates(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_generate_texture_coordinates( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_parametric_function_source_set_generate_texture_coordinates(self.0, _arg) + } + } + fn get_generate_texture_coordinates_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_texture_coordinates_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_function_source_get_generate_texture_coordinates_min_value( + self.0, + ) + } + } + fn get_generate_texture_coordinates_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_texture_coordinates_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_function_source_get_generate_texture_coordinates_max_value( + self.0, + ) + } + } + fn get_generate_texture_coordinates(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_texture_coordinates( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_parametric_function_source_get_generate_texture_coordinates(self.0) + } + } + fn generate_normals_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_generate_normals_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_generate_normals_on(self.0) } + } + fn generate_normals_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_generate_normals_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_generate_normals_off(self.0) } + } + fn set_generate_normals(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_generate_normals( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_generate_normals(self.0, _arg) } + } + fn get_generate_normals_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_normals_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_generate_normals_min_value(self.0) } + } + fn get_generate_normals_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_normals_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_generate_normals_max_value(self.0) } + } + fn get_generate_normals(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_generate_normals( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_generate_normals(self.0) } + } + fn set_scalar_mode(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode(self.0, _arg) } + } + fn get_scalar_mode_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_scalar_mode_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_scalar_mode_min_value(self.0) } + } + fn get_scalar_mode_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_scalar_mode_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_scalar_mode_max_value(self.0) } + } + fn get_scalar_mode(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_scalar_mode( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_scalar_mode(self.0) } + } + fn set_scalar_mode_to_none(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_none( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_none(self.0) } + } + fn set_scalar_mode_to_u(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_u( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_u(self.0) } + } + fn set_scalar_mode_to_v(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_v( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_v(self.0) } + } + fn set_scalar_mode_to_u_0(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_u_0( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_u_0(self.0) } + } + fn set_scalar_mode_to_v_0(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_v_0( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_v_0(self.0) } + } + fn set_scalar_mode_to_u_0_v_0(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_u_0_v_0( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_u_0_v_0(self.0) } + } + fn set_scalar_mode_to_modulus(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_modulus( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_modulus(self.0) } + } + fn set_scalar_mode_to_phase(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_phase( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_phase(self.0) } + } + fn set_scalar_mode_to_quadrant(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_quadrant( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_quadrant(self.0) } + } + fn set_scalar_mode_to_x(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_x( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_x(self.0) } + } + fn set_scalar_mode_to_y(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_y( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_y(self.0) } + } + fn set_scalar_mode_to_z(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_z( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_z(self.0) } + } + fn set_scalar_mode_to_distance(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_distance( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_parametric_function_source_set_scalar_mode_to_distance(self.0) } + } + fn set_scalar_mode_to_function_defined(&mut self) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_scalar_mode_to_function_defined( + sself: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_parametric_function_source_set_scalar_mode_to_function_defined(self.0) + } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_parametric_function_source_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_parametric_function_source_get_m_time(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_parametric_function_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_parametric_function_source_set_output_points_precision(self.0, _arg) + } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_parametric_function_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_parametric_function_source_get_output_points_precision(self.0) } + } +} +impl VtkPartitionedDataSetCollectionSource for vtkPartitionedDataSetCollectionSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_collection_source_new_instance(self.0) } + } + fn set_number_of_shapes(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_set_number_of_shapes( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_partitioned_data_set_collection_source_set_number_of_shapes(self.0, _arg) + } + } + fn get_number_of_shapes_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_collection_source_get_number_of_shapes_min_value( + self.0, + ) + } + } + fn get_number_of_shapes_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_collection_source_get_number_of_shapes_max_value( + self.0, + ) + } + } + fn get_number_of_shapes(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_collection_source_get_number_of_shapes( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_collection_source_get_number_of_shapes(self.0) + } + } +} +impl VtkPartitionedDataSetSource for vtkPartitionedDataSetSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_source_new_instance(self.0) } + } + fn enable_rank(&mut self, rank: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_enable_rank( + sself: *mut core::ffi::c_void, + rank: core::ffi::c_int, + ); + } + unsafe { vtk_partitioned_data_set_source_enable_rank(self.0, rank) } + } + fn enable_all_ranks(&mut self) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_enable_all_ranks( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_source_enable_all_ranks(self.0) } + } + fn disable_rank(&mut self, rank: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_disable_rank( + sself: *mut core::ffi::c_void, + rank: core::ffi::c_int, + ); + } + unsafe { vtk_partitioned_data_set_source_disable_rank(self.0, rank) } + } + fn disable_all_ranks(&mut self) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_disable_all_ranks( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_source_disable_all_ranks(self.0) } + } + fn is_enabled_rank(&mut self, rank: core::ffi::c_int) -> bool { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_is_enabled_rank( + sself: *mut core::ffi::c_void, + rank: core::ffi::c_int, + ) -> bool; + } + unsafe { vtk_partitioned_data_set_source_is_enabled_rank(self.0, rank) } + } + fn set_number_of_partitions(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_set_number_of_partitions( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_partitioned_data_set_source_set_number_of_partitions(self.0, _arg) } + } + fn get_number_of_partitions_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_get_number_of_partitions_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_source_get_number_of_partitions_min_value(self.0) + } + } + fn get_number_of_partitions_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_get_number_of_partitions_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { + vtk_partitioned_data_set_source_get_number_of_partitions_max_value(self.0) + } + } + fn get_number_of_partitions(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_get_number_of_partitions( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_partitioned_data_set_source_get_number_of_partitions(self.0) } + } + fn set_parametric_function(&mut self, p0: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_set_parametric_function( + sself: *mut core::ffi::c_void, + p0: *mut core::ffi::c_void, + ); + } + unsafe { vtk_partitioned_data_set_source_set_parametric_function(self.0, p0) } + } + fn get_parametric_function(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_partitioned_data_set_source_get_parametric_function( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_partitioned_data_set_source_get_parametric_function(self.0) } + } +} +impl VtkPlaneSource for vtkPlaneSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_plane_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_plane_source_new(self.0) } + } + fn set_x_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_x_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_set_x_resolution(self.0, _arg) } + } + fn get_x_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_source_get_x_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_source_get_x_resolution(self.0) } + } + fn set_y_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_y_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_set_y_resolution(self.0, _arg) } + } + fn get_y_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_source_get_y_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_source_get_y_resolution(self.0) } + } + fn set_resolution(&mut self, xR: core::ffi::c_int, yR: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_resolution( + sself: *mut core::ffi::c_void, + xR: core::ffi::c_int, + yR: core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_set_resolution(self.0, xR, yR) } + } + fn get_resolution( + &mut self, + xR: &mut core::ffi::c_int, + yR: &mut core::ffi::c_int, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_get_resolution( + sself: *mut core::ffi::c_void, + xR: &mut core::ffi::c_int, + yR: &mut core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_get_resolution(self.0, xR, yR) } + } + fn set_origin( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_origin( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_origin(self.0, _arg1, _arg2, _arg3) } + } + fn set_point_1( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_point_1( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_point_1(self.0, x, y, z) } + } + fn set_point_2( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_point_2( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_point_2(self.0, x, y, z) } + } + fn set_center( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_center( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_center(self.0, x, y, z) } + } + fn set_normal( + &mut self, + nx: core::ffi::c_double, + ny: core::ffi::c_double, + nz: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_normal( + sself: *mut core::ffi::c_void, + nx: core::ffi::c_double, + ny: core::ffi::c_double, + nz: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_set_normal(self.0, nx, ny, nz) } + } + fn push(&mut self, distance: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_plane_source_push( + sself: *mut core::ffi::c_void, + distance: core::ffi::c_double, + ); + } + unsafe { vtk_plane_source_push(self.0, distance) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_plane_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_plane_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_plane_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_plane_source_get_output_points_precision(self.0) } + } +} +impl VtkPlatonicSolidSource for vtkPlatonicSolidSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_platonic_solid_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_platonic_solid_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_platonic_solid_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_platonic_solid_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_platonic_solid_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_platonic_solid_source_new_instance(self.0) } + } + fn set_solid_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type(self.0, _arg) } + } + fn get_solid_type_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_platonic_solid_source_get_solid_type_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_platonic_solid_source_get_solid_type_min_value(self.0) } + } + fn get_solid_type_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_platonic_solid_source_get_solid_type_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_platonic_solid_source_get_solid_type_max_value(self.0) } + } + fn get_solid_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_platonic_solid_source_get_solid_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_platonic_solid_source_get_solid_type(self.0) } + } + fn set_solid_type_to_tetrahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_tetrahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_tetrahedron(self.0) } + } + fn set_solid_type_to_cube(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_cube( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_cube(self.0) } + } + fn set_solid_type_to_octahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_octahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_octahedron(self.0) } + } + fn set_solid_type_to_icosahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_icosahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_icosahedron(self.0) } + } + fn set_solid_type_to_dodecahedron(&mut self) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_solid_type_to_dodecahedron( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_platonic_solid_source_set_solid_type_to_dodecahedron(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_platonic_solid_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_platonic_solid_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_platonic_solid_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_platonic_solid_source_get_output_points_precision(self.0) } + } +} +impl VtkPointHandleSource for vtkPointHandleSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_handle_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_handle_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_handle_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_handle_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_handle_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_handle_source_new_instance(self.0) } + } + fn set_position( + &mut self, + xPos: core::ffi::c_double, + yPos: core::ffi::c_double, + zPos: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_point_handle_source_set_position( + sself: *mut core::ffi::c_void, + xPos: core::ffi::c_double, + yPos: core::ffi::c_double, + zPos: core::ffi::c_double, + ); + } + unsafe { vtk_point_handle_source_set_position(self.0, xPos, yPos, zPos) } + } + fn set_direction( + &mut self, + xDir: core::ffi::c_double, + yDir: core::ffi::c_double, + zDir: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_point_handle_source_set_direction( + sself: *mut core::ffi::c_void, + xDir: core::ffi::c_double, + yDir: core::ffi::c_double, + zDir: core::ffi::c_double, + ); + } + unsafe { vtk_point_handle_source_set_direction(self.0, xDir, yDir, zDir) } + } +} +impl VtkPointSource for vtkPointSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_source_new_instance(self.0) } + } + fn set_number_of_points(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_point_source_set_number_of_points( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_point_source_set_number_of_points(self.0, _arg) } + } + fn get_number_of_points_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_source_get_number_of_points_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_source_get_number_of_points_min_value(self.0) } + } + fn get_number_of_points_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_source_get_number_of_points_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_source_get_number_of_points_max_value(self.0) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_point_source_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_point_source_get_number_of_points(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_point_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_point_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_point_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_point_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_point_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_point_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_point_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_point_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_point_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_point_source_get_radius(self.0) } + } + fn set_distribution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_point_source_set_distribution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_point_source_set_distribution(self.0, _arg) } + } + fn set_distribution_to_uniform(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_source_set_distribution_to_uniform( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_source_set_distribution_to_uniform(self.0) } + } + fn set_distribution_to_shell(&mut self) -> () { + unsafe extern "C" { + fn vtk_point_source_set_distribution_to_shell(sself: *mut core::ffi::c_void); + } + unsafe { vtk_point_source_set_distribution_to_shell(self.0) } + } + fn get_distribution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_source_get_distribution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_source_get_distribution(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_point_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_point_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_point_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_point_source_get_output_points_precision(self.0) } + } + fn set_random_sequence(&mut self, randomSequence: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_point_source_set_random_sequence( + sself: *mut core::ffi::c_void, + randomSequence: *mut core::ffi::c_void, + ); + } + unsafe { vtk_point_source_set_random_sequence(self.0, randomSequence) } + } + fn get_random_sequence(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_point_source_get_random_sequence( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_point_source_get_random_sequence(self.0) } + } +} +impl VtkPolyLineSource for vtkPolyLineSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_line_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_line_source_new_instance(self.0) } + } + fn set_closed(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_poly_line_source_set_closed( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_poly_line_source_set_closed(self.0, _arg) } + } + fn get_closed(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_poly_line_source_get_closed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_poly_line_source_get_closed(self.0) } + } + fn closed_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_line_source_closed_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_line_source_closed_on(self.0) } + } + fn closed_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_poly_line_source_closed_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_poly_line_source_closed_off(self.0) } + } +} +impl VtkPolyPointSource for vtkPolyPointSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_point_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_point_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_point_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_point_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_point_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_point_source_new_instance(self.0) } + } + fn set_number_of_points(&mut self, numPoints: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_point_source_set_number_of_points( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_point_source_set_number_of_points(self.0, numPoints) } + } + fn get_number_of_points(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_poly_point_source_get_number_of_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_poly_point_source_get_number_of_points(self.0) } + } + fn resize(&mut self, numPoints: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_poly_point_source_resize( + sself: *mut core::ffi::c_void, + numPoints: core::ffi::c_longlong, + ); + } + unsafe { vtk_poly_point_source_resize(self.0, numPoints) } + } + fn set_point( + &mut self, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_poly_point_source_set_point( + sself: *mut core::ffi::c_void, + id: core::ffi::c_longlong, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_poly_point_source_set_point(self.0, id, x, y, z) } + } + fn set_points(&mut self, points: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_poly_point_source_set_points( + sself: *mut core::ffi::c_void, + points: *mut core::ffi::c_void, + ); + } + unsafe { vtk_poly_point_source_set_points(self.0, points) } + } + fn get_points(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_poly_point_source_get_points( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_poly_point_source_get_points(self.0) } + } + fn get_m_time(&mut self) -> core::ffi::c_ulong { + unsafe extern "C" { + fn vtk_poly_point_source_get_m_time( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_ulong; + } + unsafe { vtk_poly_point_source_get_m_time(self.0) } + } +} +impl VtkProgrammableDataObjectSource for vtkProgrammableDataObjectSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_data_object_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_data_object_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_data_object_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_data_object_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_data_object_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_data_object_source_new_instance(self.0) } + } + fn set_execute_method_arg_delete(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_programmable_data_object_source_set_execute_method_arg_delete( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { + vtk_programmable_data_object_source_set_execute_method_arg_delete(self.0, f) + } + } +} +impl VtkProgrammableSource for vtkProgrammableSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_new_instance(self.0) } + } + fn set_execute_method_arg_delete(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_programmable_source_set_execute_method_arg_delete( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_programmable_source_set_execute_method_arg_delete(self.0, f) } + } + fn set_request_information_method(&mut self, f: *mut core::ffi::c_void) -> () { + unsafe extern "C" { + fn vtk_programmable_source_set_request_information_method( + sself: *mut core::ffi::c_void, + f: *mut core::ffi::c_void, + ); + } + unsafe { vtk_programmable_source_set_request_information_method(self.0, f) } + } + fn get_poly_data_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_poly_data_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_poly_data_output(self.0) } + } + fn get_structured_points_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_structured_points_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_structured_points_output(self.0) } + } + fn get_structured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_structured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_structured_grid_output(self.0) } + } + fn get_unstructured_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_unstructured_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_unstructured_grid_output(self.0) } + } + fn get_rectilinear_grid_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_rectilinear_grid_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_rectilinear_grid_output(self.0) } + } + fn get_graph_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_graph_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_graph_output(self.0) } + } + fn get_molecule_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_molecule_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_molecule_output(self.0) } + } + fn get_table_output(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_programmable_source_get_table_output( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_programmable_source_get_table_output(self.0) } + } +} +impl VtkRandomHyperTreeGridSource for vtkRandomHyperTreeGridSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_hyper_tree_grid_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_hyper_tree_grid_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_random_hyper_tree_grid_source_new_instance(self.0) } + } + fn set_dimensions( + &mut self, + _arg1: core::ffi::c_uint, + _arg2: core::ffi::c_uint, + _arg3: core::ffi::c_uint, + ) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_dimensions( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_uint, + _arg2: core::ffi::c_uint, + _arg3: core::ffi::c_uint, + ); + } + unsafe { + vtk_random_hyper_tree_grid_source_set_dimensions(self.0, _arg1, _arg2, _arg3) + } + } + fn set_output_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_output_bounds( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ); + } + unsafe { + vtk_random_hyper_tree_grid_source_set_output_bounds( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn get_seed(&mut self) -> core::ffi::c_uint { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_seed( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_uint; + } + unsafe { vtk_random_hyper_tree_grid_source_get_seed(self.0) } + } + fn set_seed(&mut self, _arg: core::ffi::c_uint) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_seed( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_uint, + ); + } + unsafe { vtk_random_hyper_tree_grid_source_set_seed(self.0, _arg) } + } + fn get_max_depth(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_max_depth( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_hyper_tree_grid_source_get_max_depth(self.0) } + } + fn set_max_depth(&mut self, _arg: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_max_depth( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_longlong, + ); + } + unsafe { vtk_random_hyper_tree_grid_source_set_max_depth(self.0, _arg) } + } + fn get_max_depth_min_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_max_depth_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_hyper_tree_grid_source_get_max_depth_min_value(self.0) } + } + fn get_max_depth_max_value(&mut self) -> core::ffi::c_longlong { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_max_depth_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_longlong; + } + unsafe { vtk_random_hyper_tree_grid_source_get_max_depth_max_value(self.0) } + } + fn get_split_fraction(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_split_fraction( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_hyper_tree_grid_source_get_split_fraction(self.0) } + } + fn set_split_fraction(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_set_split_fraction( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_random_hyper_tree_grid_source_set_split_fraction(self.0, _arg) } + } + fn get_split_fraction_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_split_fraction_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_hyper_tree_grid_source_get_split_fraction_min_value(self.0) } + } + fn get_split_fraction_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_random_hyper_tree_grid_source_get_split_fraction_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_random_hyper_tree_grid_source_get_split_fraction_max_value(self.0) } + } +} +impl VtkRectangularButtonSource for vtkRectangularButtonSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectangular_button_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectangular_button_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectangular_button_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectangular_button_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_rectangular_button_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_rectangular_button_source_new(self.0) } + } + fn set_width(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_width( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_width(self.0, _arg) } + } + fn get_width_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_width_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_width_min_value(self.0) } + } + fn get_width_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_width_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_width_max_value(self.0) } + } + fn get_width(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_width( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_width(self.0) } + } + fn set_height(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_height( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_height(self.0, _arg) } + } + fn get_height_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_height_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_height_min_value(self.0) } + } + fn get_height_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_height_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_height_max_value(self.0) } + } + fn get_height(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_height( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_height(self.0) } + } + fn set_depth(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_depth( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_depth(self.0, _arg) } + } + fn get_depth_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_depth_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_depth_min_value(self.0) } + } + fn get_depth_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_depth_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_depth_max_value(self.0) } + } + fn get_depth(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_depth( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_depth(self.0) } + } + fn set_box_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_box_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_box_ratio(self.0, _arg) } + } + fn get_box_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_box_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_box_ratio_min_value(self.0) } + } + fn get_box_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_box_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_box_ratio_max_value(self.0) } + } + fn get_box_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_box_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_box_ratio(self.0) } + } + fn set_texture_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_texture_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_texture_ratio(self.0, _arg) } + } + fn get_texture_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_texture_ratio_min_value(self.0) } + } + fn get_texture_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_texture_ratio_max_value(self.0) } + } + fn get_texture_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_texture_ratio(self.0) } + } + fn set_texture_height_ratio(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_texture_height_ratio( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_rectangular_button_source_set_texture_height_ratio(self.0, _arg) } + } + fn get_texture_height_ratio_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_height_ratio_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_rectangular_button_source_get_texture_height_ratio_min_value(self.0) + } + } + fn get_texture_height_ratio_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_height_ratio_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { + vtk_rectangular_button_source_get_texture_height_ratio_max_value(self.0) + } + } + fn get_texture_height_ratio(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_texture_height_ratio( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_rectangular_button_source_get_texture_height_ratio(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_rectangular_button_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { + vtk_rectangular_button_source_set_output_points_precision(self.0, _arg) + } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_rectangular_button_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_rectangular_button_source_get_output_points_precision(self.0) } + } +} +impl VtkRegularPolygonSource for vtkRegularPolygonSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_regular_polygon_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_regular_polygon_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_regular_polygon_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_regular_polygon_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_regular_polygon_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_regular_polygon_source_new_instance(self.0) } + } + fn set_number_of_sides(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_number_of_sides( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_regular_polygon_source_set_number_of_sides(self.0, _arg) } + } + fn get_number_of_sides_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_number_of_sides_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_number_of_sides_min_value(self.0) } + } + fn get_number_of_sides_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_number_of_sides_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_number_of_sides_max_value(self.0) } + } + fn get_number_of_sides(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_number_of_sides( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_number_of_sides(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_regular_polygon_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_normal( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_normal( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_regular_polygon_source_set_normal(self.0, _arg1, _arg2, _arg3) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_regular_polygon_source_set_radius(self.0, _arg) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_regular_polygon_source_get_radius(self.0) } + } + fn set_generate_polygon(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_generate_polygon( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_regular_polygon_source_set_generate_polygon(self.0, _arg) } + } + fn get_generate_polygon(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_generate_polygon( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_generate_polygon(self.0) } + } + fn generate_polygon_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_generate_polygon_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_regular_polygon_source_generate_polygon_on(self.0) } + } + fn generate_polygon_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_generate_polygon_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_regular_polygon_source_generate_polygon_off(self.0) } + } + fn set_generate_polyline(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_generate_polyline( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_regular_polygon_source_set_generate_polyline(self.0, _arg) } + } + fn get_generate_polyline(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_generate_polyline( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_generate_polyline(self.0) } + } + fn generate_polyline_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_generate_polyline_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_regular_polygon_source_generate_polyline_on(self.0) } + } + fn generate_polyline_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_generate_polyline_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_regular_polygon_source_generate_polyline_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_regular_polygon_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_regular_polygon_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_regular_polygon_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_regular_polygon_source_get_output_points_precision(self.0) } + } +} +impl VtkSelectionSource for vtkSelectionSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_selection_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_selection_source_new_instance(self.0) } + } + fn add_id(&mut self, piece: core::ffi::c_longlong, id: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_selection_source_add_id( + sself: *mut core::ffi::c_void, + piece: core::ffi::c_longlong, + id: core::ffi::c_longlong, + ); + } + unsafe { vtk_selection_source_add_id(self.0, piece, id) } + } + fn add_string_id(&mut self, piece: core::ffi::c_longlong, id: &str) -> () { + let c_id = std::ffi::CString::new(id).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_add_string_id( + sself: *mut core::ffi::c_void, + piece: core::ffi::c_longlong, + id: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_add_string_id(self.0, piece, c_id.as_ptr()) } + } + fn add_location( + &mut self, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_selection_source_add_location( + sself: *mut core::ffi::c_void, + x: core::ffi::c_double, + y: core::ffi::c_double, + z: core::ffi::c_double, + ); + } + unsafe { vtk_selection_source_add_location(self.0, x, y, z) } + } + fn add_threshold( + &mut self, + min: core::ffi::c_double, + max: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_selection_source_add_threshold( + sself: *mut core::ffi::c_void, + min: core::ffi::c_double, + max: core::ffi::c_double, + ); + } + unsafe { vtk_selection_source_add_threshold(self.0, min, max) } + } + fn add_block(&mut self, blockno: core::ffi::c_longlong) -> () { + unsafe extern "C" { + fn vtk_selection_source_add_block( + sself: *mut core::ffi::c_void, + blockno: core::ffi::c_longlong, + ); + } + unsafe { vtk_selection_source_add_block(self.0, blockno) } + } + fn add_block_selector(&mut self, selector: &str) -> () { + let c_selector = std::ffi::CString::new(selector).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_add_block_selector( + sself: *mut core::ffi::c_void, + selector: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_add_block_selector(self.0, c_selector.as_ptr()) } + } + fn remove_all_block_selectors(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_block_selectors( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_source_remove_all_block_selectors(self.0) } + } + fn remove_all_i_ds(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_i_ds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_i_ds(self.0) } + } + fn remove_all_string_i_ds(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_string_i_ds( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_selection_source_remove_all_string_i_ds(self.0) } + } + fn remove_all_thresholds(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_thresholds(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_thresholds(self.0) } + } + fn remove_all_locations(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_locations(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_locations(self.0) } + } + fn remove_all_blocks(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_blocks(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_blocks(self.0) } + } + fn set_content_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_content_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_content_type(self.0, _arg) } + } + fn get_content_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_content_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_content_type(self.0) } + } + fn set_field_type(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_field_type( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_field_type(self.0, _arg) } + } + fn get_field_type(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_field_type( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_field_type(self.0) } + } + fn set_containing_cells(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_containing_cells( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_containing_cells(self.0, _arg) } + } + fn get_containing_cells(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_containing_cells( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_containing_cells(self.0) } + } + fn set_number_of_layers(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_number_of_layers( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_number_of_layers(self.0, _arg) } + } + fn get_number_of_layers_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_number_of_layers_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_number_of_layers_min_value(self.0) } + } + fn get_number_of_layers_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_number_of_layers_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_number_of_layers_max_value(self.0) } + } + fn get_number_of_layers(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_number_of_layers( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_number_of_layers(self.0) } + } + fn set_inverse(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_inverse( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_inverse(self.0, _arg) } + } + fn get_inverse(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_inverse( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_inverse(self.0) } + } + fn set_array_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_set_array_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_set_array_name(self.0, c__arg.as_ptr()) } + } + fn set_array_component(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_array_component( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_array_component(self.0, _arg) } + } + fn get_array_component(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_array_component( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_array_component(self.0) } + } + fn set_composite_index(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_composite_index( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_composite_index(self.0, _arg) } + } + fn get_composite_index(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_composite_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_composite_index(self.0) } + } + fn set_hierarchical_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_hierarchical_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_hierarchical_level(self.0, _arg) } + } + fn get_hierarchical_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_hierarchical_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_hierarchical_level(self.0) } + } + fn set_hierarchical_index(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_selection_source_set_hierarchical_index( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_selection_source_set_hierarchical_index(self.0, _arg) } + } + fn get_hierarchical_index(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_selection_source_get_hierarchical_index( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_selection_source_get_hierarchical_index(self.0) } + } + fn set_assembly_name(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_set_assembly_name( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_set_assembly_name(self.0, c__arg.as_ptr()) } + } + fn add_selector(&mut self, selector: &str) -> () { + let c_selector = std::ffi::CString::new(selector).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_add_selector( + sself: *mut core::ffi::c_void, + selector: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_add_selector(self.0, c_selector.as_ptr()) } + } + fn remove_all_selectors(&mut self) -> () { + unsafe extern "C" { + fn vtk_selection_source_remove_all_selectors(sself: *mut core::ffi::c_void); + } + unsafe { vtk_selection_source_remove_all_selectors(self.0) } + } + fn set_query_string(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_selection_source_set_query_string( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_selection_source_set_query_string(self.0, c__arg.as_ptr()) } + } +} +impl VtkSphereSource for vtkSphereSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_sphere_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_sphere_source_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_radius(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_theta_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_theta_resolution(self.0, _arg) } + } + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_theta_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_theta_resolution_min_value(self.0) } + } + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_theta_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_theta_resolution_max_value(self.0) } + } + fn get_theta_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_theta_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_theta_resolution(self.0) } + } + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_phi_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_phi_resolution(self.0, _arg) } + } + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_phi_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_phi_resolution_min_value(self.0) } + } + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_phi_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_phi_resolution_max_value(self.0) } + } + fn get_phi_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_phi_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_phi_resolution(self.0) } + } + fn set_start_theta(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_start_theta( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_start_theta(self.0, _arg) } + } + fn get_start_theta_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_theta_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_theta_min_value(self.0) } + } + fn get_start_theta_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_theta_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_theta_max_value(self.0) } + } + fn get_start_theta(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_theta( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_theta(self.0) } + } + fn set_end_theta(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_end_theta( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_end_theta(self.0, _arg) } + } + fn get_end_theta_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_theta_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_theta_min_value(self.0) } + } + fn get_end_theta_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_theta_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_theta_max_value(self.0) } + } + fn get_end_theta(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_theta( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_theta(self.0) } + } + fn set_start_phi(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_start_phi( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_start_phi(self.0, _arg) } + } + fn get_start_phi_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_phi_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_phi_min_value(self.0) } + } + fn get_start_phi_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_phi_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_phi_max_value(self.0) } + } + fn get_start_phi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_start_phi( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_start_phi(self.0) } + } + fn set_end_phi(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_end_phi( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_sphere_source_set_end_phi(self.0, _arg) } + } + fn get_end_phi_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_phi_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_phi_min_value(self.0) } + } + fn get_end_phi_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_phi_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_phi_max_value(self.0) } + } + fn get_end_phi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_sphere_source_get_end_phi( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_sphere_source_get_end_phi(self.0) } + } + fn set_lat_long_tessellation(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_lat_long_tessellation( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_lat_long_tessellation(self.0, _arg) } + } + fn get_lat_long_tessellation(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_lat_long_tessellation( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_lat_long_tessellation(self.0) } + } + fn lat_long_tessellation_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_source_lat_long_tessellation_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_source_lat_long_tessellation_on(self.0) } + } + fn lat_long_tessellation_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_source_lat_long_tessellation_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_sphere_source_lat_long_tessellation_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_output_points_precision(self.0) } + } + fn set_generate_normals(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_sphere_source_set_generate_normals( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_sphere_source_set_generate_normals(self.0, _arg) } + } + fn get_generate_normals(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_sphere_source_get_generate_normals( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_sphere_source_get_generate_normals(self.0) } + } + fn generate_normals_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_source_generate_normals_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_source_generate_normals_on(self.0) } + } + fn generate_normals_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_sphere_source_generate_normals_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_sphere_source_generate_normals_off(self.0) } + } +} +impl VtkSuperquadricSource for vtkSuperquadricSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_superquadric_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_superquadric_source_new_instance(self.0) } + } + fn set_center( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_center( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_center(self.0, _arg1, _arg2, _arg3) } + } + fn set_scale( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_scale( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_scale(self.0, _arg1, _arg2, _arg3) } + } + fn get_theta_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_theta_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_theta_resolution(self.0) } + } + fn set_theta_resolution(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_theta_resolution( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_theta_resolution(self.0, i) } + } + fn get_phi_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_phi_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_phi_resolution(self.0) } + } + fn set_phi_resolution(&mut self, i: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_phi_resolution( + sself: *mut core::ffi::c_void, + i: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_phi_resolution(self.0, i) } + } + fn get_thickness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_thickness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_thickness(self.0) } + } + fn set_thickness(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_thickness( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_thickness(self.0, _arg) } + } + fn get_thickness_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_thickness_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_thickness_min_value(self.0) } + } + fn get_thickness_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_thickness_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_thickness_max_value(self.0) } + } + fn get_phi_roundness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_phi_roundness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_phi_roundness(self.0) } + } + fn set_phi_roundness(&mut self, e: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_phi_roundness( + sself: *mut core::ffi::c_void, + e: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_phi_roundness(self.0, e) } + } + fn get_theta_roundness(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_theta_roundness( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_theta_roundness(self.0) } + } + fn set_theta_roundness(&mut self, e: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_theta_roundness( + sself: *mut core::ffi::c_void, + e: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_theta_roundness(self.0, e) } + } + fn set_size(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_size( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_superquadric_source_set_size(self.0, _arg) } + } + fn get_size(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_superquadric_source_get_size( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_superquadric_source_get_size(self.0) } + } + fn set_axis_of_symmetry(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_axis_of_symmetry( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_axis_of_symmetry(self.0, _arg) } + } + fn get_axis_of_symmetry(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_axis_of_symmetry( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_axis_of_symmetry(self.0) } + } + fn set_x_axis_of_symmetry(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_x_axis_of_symmetry( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_superquadric_source_set_x_axis_of_symmetry(self.0) } + } + fn set_y_axis_of_symmetry(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_y_axis_of_symmetry( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_superquadric_source_set_y_axis_of_symmetry(self.0) } + } + fn set_z_axis_of_symmetry(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_z_axis_of_symmetry( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_superquadric_source_set_z_axis_of_symmetry(self.0) } + } + fn toroidal_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_toroidal_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_superquadric_source_toroidal_on(self.0) } + } + fn toroidal_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_toroidal_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_superquadric_source_toroidal_off(self.0) } + } + fn get_toroidal(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_toroidal( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_toroidal(self.0) } + } + fn set_toroidal(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_toroidal( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_toroidal(self.0, _arg) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_superquadric_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_superquadric_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_superquadric_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_superquadric_source_get_output_points_precision(self.0) } + } +} +impl VtkTessellatedBoxSource for vtkTessellatedBoxSource { + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tessellated_box_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tessellated_box_source_new(self.0) } + } + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tessellated_box_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tessellated_box_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_tessellated_box_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_tessellated_box_source_new_instance(self.0) } + } + fn set_bounds( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_bounds( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + _arg4: core::ffi::c_double, + _arg5: core::ffi::c_double, + _arg6: core::ffi::c_double, + ); + } + unsafe { + vtk_tessellated_box_source_set_bounds( + self.0, + _arg1, + _arg2, + _arg3, + _arg4, + _arg5, + _arg6, + ) + } + } + fn set_level(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_level( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_tessellated_box_source_set_level(self.0, _arg) } + } + fn get_level(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tessellated_box_source_get_level( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tessellated_box_source_get_level(self.0) } + } + fn set_duplicate_shared_points(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_duplicate_shared_points( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_tessellated_box_source_set_duplicate_shared_points(self.0, _arg) } + } + fn get_duplicate_shared_points(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tessellated_box_source_get_duplicate_shared_points( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tessellated_box_source_get_duplicate_shared_points(self.0) } + } + fn duplicate_shared_points_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_duplicate_shared_points_on( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tessellated_box_source_duplicate_shared_points_on(self.0) } + } + fn duplicate_shared_points_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_duplicate_shared_points_off( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtk_tessellated_box_source_duplicate_shared_points_off(self.0) } + } + fn set_quads(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_quads( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_tessellated_box_source_set_quads(self.0, _arg) } + } + fn get_quads(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tessellated_box_source_get_quads( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tessellated_box_source_get_quads(self.0) } + } + fn quads_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_quads_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_tessellated_box_source_quads_on(self.0) } + } + fn quads_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_quads_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_tessellated_box_source_quads_off(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_tessellated_box_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_tessellated_box_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_tessellated_box_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_tessellated_box_source_get_output_points_precision(self.0) } + } +} +impl VtkTextSource for vtkTextSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_text_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_text_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_text_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_text_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_text_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_text_source_new(self.0) } + } + fn set_text(&mut self, _arg: &str) -> () { + let c__arg = std::ffi::CString::new(_arg).expect("CString::new failed"); + unsafe extern "C" { + fn vtk_text_source_set_text( + sself: *mut core::ffi::c_void, + _arg: *const core::ffi::c_char, + ); + } + unsafe { vtk_text_source_set_text(self.0, c__arg.as_ptr()) } + } + fn set_backing(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_text_source_set_backing( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_text_source_set_backing(self.0, _arg) } + } + fn get_backing(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_text_source_get_backing( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_text_source_get_backing(self.0) } + } + fn backing_on(&mut self) -> () { + unsafe extern "C" { + fn vtk_text_source_backing_on(sself: *mut core::ffi::c_void); + } + unsafe { vtk_text_source_backing_on(self.0) } + } + fn backing_off(&mut self) -> () { + unsafe extern "C" { + fn vtk_text_source_backing_off(sself: *mut core::ffi::c_void); + } + unsafe { vtk_text_source_backing_off(self.0) } + } + fn set_foreground_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_text_source_set_foreground_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_text_source_set_foreground_color(self.0, _arg1, _arg2, _arg3) } + } + fn set_background_color( + &mut self, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ) -> () { + unsafe extern "C" { + fn vtk_text_source_set_background_color( + sself: *mut core::ffi::c_void, + _arg1: core::ffi::c_double, + _arg2: core::ffi::c_double, + _arg3: core::ffi::c_double, + ); + } + unsafe { vtk_text_source_set_background_color(self.0, _arg1, _arg2, _arg3) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_text_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_text_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_text_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_text_source_get_output_points_precision(self.0) } + } +} +impl VtkTexturedSphereSource for vtkTexturedSphereSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_textured_sphere_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_textured_sphere_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_textured_sphere_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_textured_sphere_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_textured_sphere_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_textured_sphere_source_new(self.0) } + } + fn set_radius(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_radius( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_textured_sphere_source_set_radius(self.0, _arg) } + } + fn get_radius_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_radius_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_radius_min_value(self.0) } + } + fn get_radius_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_radius_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_radius_max_value(self.0) } + } + fn get_radius(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_radius( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_radius(self.0) } + } + fn set_theta_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_theta_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_textured_sphere_source_set_theta_resolution(self.0, _arg) } + } + fn get_theta_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_theta_resolution_min_value(self.0) } + } + fn get_theta_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_theta_resolution_max_value(self.0) } + } + fn get_theta_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_theta_resolution(self.0) } + } + fn set_phi_resolution(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_phi_resolution( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_textured_sphere_source_set_phi_resolution(self.0, _arg) } + } + fn get_phi_resolution_min_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_resolution_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_phi_resolution_min_value(self.0) } + } + fn get_phi_resolution_max_value(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_resolution_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_phi_resolution_max_value(self.0) } + } + fn get_phi_resolution(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_resolution( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_phi_resolution(self.0) } + } + fn set_theta(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_theta( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_textured_sphere_source_set_theta(self.0, _arg) } + } + fn get_theta_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_theta_min_value(self.0) } + } + fn get_theta_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_theta_max_value(self.0) } + } + fn get_theta(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_theta( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_theta(self.0) } + } + fn set_phi(&mut self, _arg: core::ffi::c_double) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_phi( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_double, + ); + } + unsafe { vtk_textured_sphere_source_set_phi(self.0, _arg) } + } + fn get_phi_min_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_min_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_phi_min_value(self.0) } + } + fn get_phi_max_value(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi_max_value( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_phi_max_value(self.0) } + } + fn get_phi(&mut self) -> core::ffi::c_double { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_phi( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_double; + } + unsafe { vtk_textured_sphere_source_get_phi(self.0) } + } + fn set_output_points_precision(&mut self, _arg: core::ffi::c_int) -> () { + unsafe extern "C" { + fn vtk_textured_sphere_source_set_output_points_precision( + sself: *mut core::ffi::c_void, + _arg: core::ffi::c_int, + ); + } + unsafe { vtk_textured_sphere_source_set_output_points_precision(self.0, _arg) } + } + fn get_output_points_precision(&mut self) -> core::ffi::c_int { + unsafe extern "C" { + fn vtk_textured_sphere_source_get_output_points_precision( + sself: *mut core::ffi::c_void, + ) -> core::ffi::c_int; + } + unsafe { vtk_textured_sphere_source_get_output_points_precision(self.0) } + } +} +impl VtkUniformHyperTreeGridSource for vtkUniformHyperTreeGridSource { + fn safe_down_cast(&mut self, o: *mut core::ffi::c_void) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_source_safe_down_cast( + sself: *mut core::ffi::c_void, + o: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_source_safe_down_cast(self.0, o) } + } + fn new_instance(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_source_new_instance( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_source_new_instance(self.0) } + } + fn new(&mut self) -> *mut core::ffi::c_void { + unsafe extern "C" { + fn vtk_uniform_hyper_tree_grid_source_new( + sself: *mut core::ffi::c_void, + ) -> *mut core::ffi::c_void; + } + unsafe { vtk_uniform_hyper_tree_grid_source_new(self.0) } + } +} +/// create a circular arc +/// +/// +/// +/// vtkArcSource is a source object that creates an arc defined by two +/// endpoints and a center. The number of segments composing the polyline +/// is controlled by setting the object resolution. +/// Alternatively, one can use a better API (that does not allow for +/// inconsistent nor ambiguous inputs), using a starting point (polar vector, +/// measured from the arc's center), a normal to the plane of the arc, +/// and an angle defining the arc length. +/// Since the default API remains the original one, in order to use +/// the improved API, one must switch the UseNormalAndAngle flag to TRUE. +/// +/// The development of an improved, consistent API (based on point, normal, +/// and angle) was supported by CEA/DIF - Commissariat a l'Energie Atomique, +/// Centre DAM Ile-De-France, BP12, F-91297 Arpajon, France, and implemented +/// by Philippe Pebay, Kitware SAS 2012. +/// +/// @sa +/// vtkEllipseArcSource +#[allow(non_camel_case_types)] +pub struct vtkArcSource(*mut core::ffi::c_void); +impl vtkArcSource { + /// Creates a new [vtkArcSource] via `vtkArcSource::New()` + #[doc(alias = "vtkArcSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkArcSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkArcSource_new() }) + } +} +impl std::default::Default for vtkArcSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkArcSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkArcSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkArcSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkArcSource_create_drop() { + let obj = vtkArcSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Appends a cylinder to a cone to form an arrow. +/// +/// +/// vtkArrowSource was intended to be used as the source for a glyph. +/// The shaft base is always at (0,0,0). The arrow tip is always at (1,0,0). If +/// "Invert" is true, then the ends are flipped i.e. tip is at (0,0,0) while +/// base is at (1, 0, 0). +/// The resolution of the cone and shaft can be set and default to 6. +/// The radius of the cone and shaft can be set and default to 0.03 and 0.1. +/// The length of the tip can also be set, and defaults to 0.35. +#[allow(non_camel_case_types)] +pub struct vtkArrowSource(*mut core::ffi::c_void); +impl vtkArrowSource { + /// Creates a new [vtkArrowSource] via `vtkArrowSource::New()` + #[doc(alias = "vtkArrowSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkArrowSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkArrowSource_new() }) + } +} +impl std::default::Default for vtkArrowSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkArrowSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkArrowSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkArrowSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkArrowSource_create_drop() { + let obj = vtkArrowSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Generate a capsule centered at the origin +/// +/// +/// vtkCapsuleSource creates a capsule (represented by polygons) of specified +/// radius centered at the origin. The resolution (polygonal discretization) in +/// both the latitude (phi) and longitude (theta) directions can be specified as +/// well as the length of the capsule cylinder (CylinderLength). By default, the +/// surface tessellation of the sphere uses triangles; however you can set +/// LatLongTessellation to produce a tessellation using quadrilaterals (except +/// at the poles of the capsule). +#[allow(non_camel_case_types)] +pub struct vtkCapsuleSource(*mut core::ffi::c_void); +impl vtkCapsuleSource { + /// Creates a new [vtkCapsuleSource] via `vtkCapsuleSource::New()` + #[doc(alias = "vtkCapsuleSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkCapsuleSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkCapsuleSource_new() }) + } +} +impl std::default::Default for vtkCapsuleSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkCapsuleSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkCapsuleSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkCapsuleSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkCapsuleSource_create_drop() { + let obj = vtkCapsuleSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Create cells of a given type +/// +/// +/// vtkCellTypeSource is a source object that creates cells of the given +/// input type. BlocksDimensions specifies the number of cell "blocks" in each +/// direction. A cell block may be divided into multiple cells based on +/// the chosen cell type (e.g. 6 pyramid cells make up a single cell block). +/// If a 1D cell is selected then only the first dimension is +/// used to specify how many cells are generated. If a 2D cell is +/// selected then only the first and second dimensions are used to +/// determine how many cells are created. The source respects pieces. +#[allow(non_camel_case_types)] +pub struct vtkCellTypeSource(*mut core::ffi::c_void); +impl vtkCellTypeSource { + /// Creates a new [vtkCellTypeSource] via `vtkCellTypeSource::New()` + #[doc(alias = "vtkCellTypeSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkCellTypeSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkCellTypeSource_new() }) + } +} +impl std::default::Default for vtkCellTypeSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkCellTypeSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkCellTypeSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkCellTypeSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkCellTypeSource_create_drop() { + let obj = vtkCellTypeSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generate polygonal cone +/// +/// +/// vtkConeSource creates a cone centered at a specified point and pointing in +/// a specified direction. (By default, the center is the origin and the +/// direction is the x-axis.) Depending upon the resolution of this object, +/// different representations are created. If resolution=0 a line is created; +/// if resolution=1, a single triangle is created; if resolution=2, two +/// crossed triangles are created. For resolution > 2, a 3D cone (with +/// resolution number of sides) is created. It also is possible to control +/// whether the bottom of the cone is capped with a (resolution-sided) +/// polygon, and to specify the height and radius of the cone. +#[allow(non_camel_case_types)] +pub struct vtkConeSource(*mut core::ffi::c_void); +impl vtkConeSource { + /// Creates a new [vtkConeSource] via `vtkConeSource::New()` + #[doc(alias = "vtkConeSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkConeSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkConeSource_new() }) + } +} +impl std::default::Default for vtkConeSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkConeSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkConeSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkConeSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkConeSource_create_drop() { + let obj = vtkConeSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a polygonal representation of a cube +/// +/// +/// vtkCubeSource creates a cube centered at origin. The cube is represented +/// with four-sided polygons. It is possible to specify the length, width, +/// and height of the cube independently. +#[allow(non_camel_case_types)] +pub struct vtkCubeSource(*mut core::ffi::c_void); +impl vtkCubeSource { + /// Creates a new [vtkCubeSource] via `vtkCubeSource::New()` + #[doc(alias = "vtkCubeSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkCubeSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkCubeSource_new() }) + } +} +impl std::default::Default for vtkCubeSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkCubeSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkCubeSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkCubeSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkCubeSource_create_drop() { + let obj = vtkCubeSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generate a cylinder centered at origin +/// +/// +/// vtkCylinderSource creates a polygonal cylinder centered at Center; +/// The axis of the cylinder is aligned along the global y-axis. +/// The height and radius of the cylinder can be specified, as well as the +/// number of sides. It is also possible to control whether the cylinder is +/// open-ended or capped. If you have the end points of the cylinder, you +/// should use a vtkLineSource followed by a vtkTubeFilter instead of the +/// vtkCylinderSource. +#[allow(non_camel_case_types)] +pub struct vtkCylinderSource(*mut core::ffi::c_void); +impl vtkCylinderSource { + /// Creates a new [vtkCylinderSource] via `vtkCylinderSource::New()` + #[doc(alias = "vtkCylinderSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkCylinderSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkCylinderSource_new() }) + } +} +impl std::default::Default for vtkCylinderSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkCylinderSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkCylinderSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkCylinderSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkCylinderSource_create_drop() { + let obj = vtkCylinderSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generates a sparse or dense square matrix +/// +/// with user-specified values for the diagonal, superdiagonal, and subdiagonal. +/// +/// @par Thanks: +/// Developed by Timothy M. Shead (tshead@sandia.gov) at Sandia National Laboratories. +#[allow(non_camel_case_types)] +pub struct vtkDiagonalMatrixSource(*mut core::ffi::c_void); +impl vtkDiagonalMatrixSource { + /// Creates a new [vtkDiagonalMatrixSource] via `vtkDiagonalMatrixSource::New()` + #[doc(alias = "vtkDiagonalMatrixSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkDiagonalMatrixSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkDiagonalMatrixSource_new() }) + } +} +impl std::default::Default for vtkDiagonalMatrixSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkDiagonalMatrixSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkDiagonalMatrixSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkDiagonalMatrixSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkDiagonalMatrixSource_create_drop() { + let obj = vtkDiagonalMatrixSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a disk with hole in center +/// +/// +/// vtkDiskSource creates a polygonal disk with a hole in the center. The +/// disk has zero height. The user can specify the inner and outer radius +/// of the disk, and the radial and circumferential resolution of the +/// polygonal representation. +/// @sa +/// vtkLinearExtrusionFilter +#[allow(non_camel_case_types)] +pub struct vtkDiskSource(*mut core::ffi::c_void); +impl vtkDiskSource { + /// Creates a new [vtkDiskSource] via `vtkDiskSource::New()` + #[doc(alias = "vtkDiskSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkDiskSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkDiskSource_new() }) + } +} +impl std::default::Default for vtkDiskSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkDiskSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkDiskSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkDiskSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkDiskSource_create_drop() { + let obj = vtkDiskSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create an elliptical arc +/// +/// +/// +/// vtkEllipseArcSource is a source object that creates an elliptical arc +/// defined by a normal, a center and the major radius vector. +/// You can define an angle to draw only a section of the ellipse. The number of +/// segments composing the polyline is controlled by setting the object +/// resolution. +/// +/// @sa +/// vtkArcSource +#[allow(non_camel_case_types)] +pub struct vtkEllipseArcSource(*mut core::ffi::c_void); +impl vtkEllipseArcSource { + /// Creates a new [vtkEllipseArcSource] via `vtkEllipseArcSource::New()` + #[doc(alias = "vtkEllipseArcSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkEllipseArcSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkEllipseArcSource_new() }) + } +} +impl std::default::Default for vtkEllipseArcSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkEllipseArcSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkEllipseArcSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkEllipseArcSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkEllipseArcSource_create_drop() { + let obj = vtkEllipseArcSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a ellipsoidal-shaped button +/// +/// +/// vtkEllipticalButtonSource creates a ellipsoidal shaped button with +/// texture coordinates suitable for application of a texture map. This +/// provides a way to make nice looking 3D buttons. The buttons are +/// represented as vtkPolyData that includes texture coordinates and +/// normals. The button lies in the x-y plane. +/// +/// To use this class you must define the major and minor axes lengths of an +/// ellipsoid (expressed as width (x), height (y) and depth (z)). The button +/// has a rectangular mesh region in the center with texture coordinates that +/// range smoothly from (0,1). (This flat region is called the texture +/// region.) The outer, curved portion of the button (called the shoulder) has +/// texture coordinates set to a user specified value (by default (0,0). +/// (This results in coloring the button curve the same color as the (s,t) +/// location of the texture map.) The resolution in the radial direction, the +/// texture region, and the shoulder region must also be set. The button can +/// be moved by specifying an origin. +/// +/// @sa +/// vtkButtonSource vtkRectangularButtonSource +#[allow(non_camel_case_types)] +pub struct vtkEllipticalButtonSource(*mut core::ffi::c_void); +impl vtkEllipticalButtonSource { + /// Creates a new [vtkEllipticalButtonSource] via `vtkEllipticalButtonSource::New()` + #[doc(alias = "vtkEllipticalButtonSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkEllipticalButtonSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkEllipticalButtonSource_new() }) + } +} +impl std::default::Default for vtkEllipticalButtonSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkEllipticalButtonSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkEllipticalButtonSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkEllipticalButtonSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkEllipticalButtonSource_create_drop() { + let obj = vtkEllipticalButtonSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a polygonal representation of a frustum +/// +/// +/// vtkFrustumSource creates a frustum defines by a set of planes. The frustum +/// is represented with four-sided polygons. It is possible to specify extra +/// lines to better visualize the field of view. +/// +/// @par Usage: +/// Typical use consists of 3 steps: +/// 1. get the planes coefficients from a vtkCamera with +/// vtkCamera::GetFrustumPlanes() +/// 2. initialize the planes with vtkPlanes::SetFrustumPlanes() with the planes +/// coefficients +/// 3. pass the vtkPlanes to a vtkFrustumSource. +#[allow(non_camel_case_types)] +pub struct vtkFrustumSource(*mut core::ffi::c_void); +impl vtkFrustumSource { + /// Creates a new [vtkFrustumSource] via `vtkFrustumSource::New()` + #[doc(alias = "vtkFrustumSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkFrustumSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkFrustumSource_new() }) + } +} +impl std::default::Default for vtkFrustumSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkFrustumSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkFrustumSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkFrustumSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkFrustumSource_create_drop() { + let obj = vtkFrustumSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create 2D glyphs represented by vtkPolyData +/// +/// +/// vtkGlyphSource2D can generate a family of 2D glyphs each of which lies +/// in the x-y plane (i.e., the z-coordinate is zero). The class is a helper +/// class to be used with vtkGlyph2D and vtkXYPlotActor. +/// +/// To use this class, specify the glyph type to use and its +/// attributes. Attributes include its position (i.e., center point), scale, +/// color, and whether the symbol is filled or not (a polygon or closed line +/// sequence). You can also put a short line through the glyph running from -x +/// to +x (the glyph looks like it's on a line), or a cross. +#[allow(non_camel_case_types)] +pub struct vtkGlyphSource2D(*mut core::ffi::c_void); +impl vtkGlyphSource2D { + /// Creates a new [vtkGlyphSource2D] via `vtkGlyphSource2D::New()` + #[doc(alias = "vtkGlyphSource2D")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkGlyphSource2D_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkGlyphSource2D_new() }) + } +} +impl std::default::Default for vtkGlyphSource2D { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkGlyphSource2D { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkGlyphSource2D_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkGlyphSource2D_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkGlyphSource2D_create_drop() { + let obj = vtkGlyphSource2D::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// convert a vtkGraph to vtkPolyData +/// +/// +/// +/// Converts a vtkGraph to a vtkPolyData. This assumes that the points +/// of the graph have already been filled (perhaps by vtkGraphLayout), +/// and coverts all the edge of the graph into lines in the polydata. +/// The vertex data is passed along to the point data, and the edge data +/// is passed along to the cell data. +/// +/// Only the owned graph edges (i.e. edges with ghost level 0) are copied +/// into the vtkPolyData. +#[allow(non_camel_case_types)] +pub struct vtkGraphToPolyData(*mut core::ffi::c_void); +impl vtkGraphToPolyData { + /// Creates a new [vtkGraphToPolyData] via `vtkGraphToPolyData::New()` + #[doc(alias = "vtkGraphToPolyData")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkGraphToPolyData_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkGraphToPolyData_new() }) + } +} +impl std::default::Default for vtkGraphToPolyData { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkGraphToPolyData { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkGraphToPolyData_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkGraphToPolyData_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkGraphToPolyData_create_drop() { + let obj = vtkGraphToPolyData::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Create a synthetic grid of hypertrees. +/// +/// +/// +/// This class uses input parameters, most notably a string descriptor, +/// to generate a vtkHyperTreeGrid instance representing the corresponding +/// tree-based AMR grid. This descriptor uses the following conventions, +/// e.g., to describe a 1-D ternary subdivision with 2 root cells +/// L0 L1 L2 +/// RR | .R. ... | ... +/// For this tree: +/// HTG: . +/// / \ +/// L0: . . +/// /|\ /|\ +/// L1: c . c c c c +/// /|\ +/// L2: c c c +/// The top level of the tree is not considered a grid level +/// NB: For ease of legibility, white spaces are allowed and ignored. +/// +/// @par Thanks: +/// This class was written by Philippe Pebay, Joachim Pouderoux, and Charles Law, Kitware 2013 +/// This class was modified by Guenole Harel and Jacques-Bernard Lekien 2014 +/// This class was modified by Philippe Pebay, 2016 +/// This work was supported by Commissariat a l'Energie Atomique (CEA/DIF) +/// CEA, DAM, DIF, F-91297 Arpajon, France. +#[allow(non_camel_case_types)] +pub struct vtkHyperTreeGridSource(*mut core::ffi::c_void); +impl vtkHyperTreeGridSource { + /// Creates a new [vtkHyperTreeGridSource] via `vtkHyperTreeGridSource::New()` + #[doc(alias = "vtkHyperTreeGridSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkHyperTreeGridSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkHyperTreeGridSource_new() }) + } +} +impl std::default::Default for vtkHyperTreeGridSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkHyperTreeGridSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkHyperTreeGridSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkHyperTreeGridSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkHyperTreeGridSource_create_drop() { + let obj = vtkHyperTreeGridSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a line defined by two end points +/// +/// +/// vtkLineSource is a source object that creates a polyline defined by +/// two endpoints or a collection of connected line segments. To define the line +/// by end points, use `SetPoint1` and `SetPoint2` methods. To define a broken +/// line comprising of multiple line segments, use `SetPoints` to provide the +/// corner points that for the line. +/// +/// Intermediate points within line segment (when specifying end points alone) or +/// each of the individual line segments (when specifying broken line) can be +/// specified in two ways. First, when `UseRegularRefinement` is true (default), +/// the `Resolution` is used to determine how many intermediate points to add +/// using regular refinement. Thus, if `Resolution` is set to 1, a mid point will +/// be added for each of the line segments resulting in a line with 3 points: the +/// two end points and the mid point. Second, when `UseRegularRefinement` is +/// false, refinement ratios for points per segment are specified using +/// `SetRefinementRatio` and `SetNumberOfRefinementRatios`. To generate same +/// points as `Resolution` set to 1, the refinement ratios will be `[0, 0.5, +/// 1.0]`. To add the end points of the line segment `0.0` and `1.0` must be +/// included in the collection of refinement ratios. +/// +/// @section ChangesVTK9 Changes in VTK 9.0 +/// +/// Prior to VTK 9.0, when broken line was being generated, the texture +/// coordinates for each of the individual breaks in the line ranged from [0.0, +/// 1.0]. This has been changed to generate texture coordinates in the range +/// [0.0, 1.0] over the entire output line irrespective of whether the line was +/// generated by simply specifying the end points or multiple line segments. +/// +/// @par Thanks: +/// This class was extended by Philippe Pebay, Kitware SAS 2011, to support +/// broken lines as well as simple lines. +#[allow(non_camel_case_types)] +pub struct vtkLineSource(*mut core::ffi::c_void); +impl vtkLineSource { + /// Creates a new [vtkLineSource] via `vtkLineSource::New()` + #[doc(alias = "vtkLineSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkLineSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkLineSource_new() }) + } +} +impl std::default::Default for vtkLineSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkLineSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkLineSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkLineSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkLineSource_create_drop() { + let obj = vtkLineSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create wireframe outline corners for arbitrary data set +/// +/// +/// vtkOutlineCornerFilter is a filter that generates wireframe outline corners of any +/// data set. The outline consists of the eight corners of the dataset +/// bounding box. +#[allow(non_camel_case_types)] +pub struct vtkOutlineCornerFilter(*mut core::ffi::c_void); +impl vtkOutlineCornerFilter { + /// Creates a new [vtkOutlineCornerFilter] via `vtkOutlineCornerFilter::New()` + #[doc(alias = "vtkOutlineCornerFilter")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkOutlineCornerFilter_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkOutlineCornerFilter_new() }) + } +} +impl std::default::Default for vtkOutlineCornerFilter { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkOutlineCornerFilter { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkOutlineCornerFilter_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkOutlineCornerFilter_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkOutlineCornerFilter_create_drop() { + let obj = vtkOutlineCornerFilter::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create wireframe outline corners around bounding box +/// +/// +/// vtkOutlineCornerSource creates wireframe outline corners around a user-specified +/// bounding box. +#[allow(non_camel_case_types)] +pub struct vtkOutlineCornerSource(*mut core::ffi::c_void); +impl vtkOutlineCornerSource { + /// Creates a new [vtkOutlineCornerSource] via `vtkOutlineCornerSource::New()` + #[doc(alias = "vtkOutlineCornerSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkOutlineCornerSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkOutlineCornerSource_new() }) + } +} +impl std::default::Default for vtkOutlineCornerSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkOutlineCornerSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkOutlineCornerSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkOutlineCornerSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkOutlineCornerSource_create_drop() { + let obj = vtkOutlineCornerSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create wireframe outline around bounding box +/// +/// +/// vtkOutlineSource creates a wireframe outline around a +/// user-specified bounding box. The outline may be created aligned +/// with the {x,y,z} axis - in which case it is defined by the 6 bounds +/// {xmin,xmax,ymin,ymax,zmin,zmax} via SetBounds(). Alternatively, the +/// box may be arbitrarily aligned, in which case it should be set via +/// the SetCorners() member. +#[allow(non_camel_case_types)] +pub struct vtkOutlineSource(*mut core::ffi::c_void); +impl vtkOutlineSource { + /// Creates a new [vtkOutlineSource] via `vtkOutlineSource::New()` + #[doc(alias = "vtkOutlineSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkOutlineSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkOutlineSource_new() }) + } +} +impl std::default::Default for vtkOutlineSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkOutlineSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkOutlineSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkOutlineSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkOutlineSource_create_drop() { + let obj = vtkOutlineSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// tessellate parametric functions +/// +/// +/// This class tessellates parametric functions. The user must specify how +/// many points in the parametric coordinate directions are required (i.e., +/// the resolution), and the mode to use to generate scalars. +/// +/// @par Thanks: +/// Andrew Maclean andrew.amaclean@gmail.com for creating and contributing +/// the class. +/// +/// @sa +/// vtkParametricFunction +/// +/// @sa +/// Implementation of parametrics for 1D lines: +/// vtkParametricSpline +/// +/// @sa +/// Subclasses of vtkParametricFunction implementing non-orentable surfaces: +/// vtkParametricBoy vtkParametricCrossCap vtkParametricFigure8Klein +/// vtkParametricKlein vtkParametricMobius vtkParametricRoman +/// +/// @sa +/// Subclasses of vtkParametricFunction implementing orientable surfaces: +/// vtkParametricConicSpiral vtkParametricDini vtkParametricEllipsoid +/// vtkParametricEnneper vtkParametricRandomHills vtkParametricSuperEllipsoid +/// vtkParametricSuperToroid vtkParametricTorus +#[allow(non_camel_case_types)] +pub struct vtkParametricFunctionSource(*mut core::ffi::c_void); +impl vtkParametricFunctionSource { + /// Creates a new [vtkParametricFunctionSource] via `vtkParametricFunctionSource::New()` + #[doc(alias = "vtkParametricFunctionSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkParametricFunctionSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkParametricFunctionSource_new() }) + } +} +impl std::default::Default for vtkParametricFunctionSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkParametricFunctionSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkParametricFunctionSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkParametricFunctionSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkParametricFunctionSource_create_drop() { + let obj = vtkParametricFunctionSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// a source that produces a vtkPartitionedDataSetCollection. +/// +/// +/// vtkPartitionedDataSetCollection generates a vtkPartitionedDataSetCollection +/// for testing purposes. It uses vtkParametricFunctionSource internally to +/// generate different types of surfaces for each partitioned dataset in the +/// collection. Each partitioned dataset is split among ranks in an even fashion. +/// Thus the number of partitions per rank for a partitioned dataset are always +/// different. +#[allow(non_camel_case_types)] +pub struct vtkPartitionedDataSetCollectionSource(*mut core::ffi::c_void); +impl vtkPartitionedDataSetCollectionSource { + /// Creates a new [vtkPartitionedDataSetCollectionSource] via `vtkPartitionedDataSetCollectionSource::New()` + #[doc(alias = "vtkPartitionedDataSetCollectionSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPartitionedDataSetCollectionSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPartitionedDataSetCollectionSource_new() }) + } +} +impl std::default::Default for vtkPartitionedDataSetCollectionSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPartitionedDataSetCollectionSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPartitionedDataSetCollectionSource_destructor( + sself: *mut core::ffi::c_void, + ); + } + unsafe { vtkPartitionedDataSetCollectionSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPartitionedDataSetCollectionSource_create_drop() { + let obj = vtkPartitionedDataSetCollectionSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// a source that produces a vtkPartitionedDataSet. +/// +/// +/// vtkPartitionedDataSetSource generates a vtkPartitionedDataSet which is +/// composed of partitions of a given vtkParametricFunction. +/// The resulting partitioned dataset is split among ranks in an even fashion +/// by default. +/// +/// The user can pass the parametric function to be used using SetParametricFunction. +/// Otherwise it will default to vtkParametricKlein as its Parametric function. +/// +/// The partitioning scheme for the produced vtkPartitionedDataSet can be controlled +/// with the methods: SetNumberOfPartitiones, EnableRank, DisableRank, EnableAllRanks, +/// DisableAllRanks. +/// +/// @see vtkParametricFunction +/// @see vtkPartitionedDataSet +#[allow(non_camel_case_types)] +pub struct vtkPartitionedDataSetSource(*mut core::ffi::c_void); +impl vtkPartitionedDataSetSource { + /// Creates a new [vtkPartitionedDataSetSource] via `vtkPartitionedDataSetSource::New()` + #[doc(alias = "vtkPartitionedDataSetSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPartitionedDataSetSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPartitionedDataSetSource_new() }) + } +} +impl std::default::Default for vtkPartitionedDataSetSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPartitionedDataSetSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPartitionedDataSetSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPartitionedDataSetSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPartitionedDataSetSource_create_drop() { + let obj = vtkPartitionedDataSetSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create an array of quadrilaterals located in a plane +/// +/// +/// vtkPlaneSource creates an m x n array of quadrilaterals arranged as +/// a regular tiling in a plane. The plane is defined by specifying an +/// origin point, and then two other points that, together with the +/// origin, define two axes for the plane. These axes do not have to be +/// orthogonal - so you can create a parallelogram. (The axes must not +/// be parallel.) The resolution of the plane (i.e., number of subdivisions) is +/// controlled by the ivars XResolution and YResolution. +/// +/// By default, the plane is centered at the origin and perpendicular to the +/// z-axis, with width and height of length 1 and resolutions set to 1. +/// +/// There are three convenience methods that allow you to easily move the +/// plane. The first, SetNormal(), allows you to specify the plane +/// normal. The effect of this method is to rotate the plane around the center +/// of the plane, aligning the plane normal with the specified normal. The +/// rotation is about the axis defined by the cross product of the current +/// normal with the new normal. The second, SetCenter(), translates the center +/// of the plane to the specified center point. The third method, Push(), +/// allows you to translate the plane along the plane normal by the distance +/// specified. (Negative Push values translate the plane in the negative +/// normal direction.) Note that the SetNormal(), SetCenter() and Push() +/// methods modify the Origin, Point1, and/or Point2 instance variables. +/// +/// @warning +/// The normal to the plane will point in the direction of the cross product +/// of the first axis (Origin->Point1) with the second (Origin->Point2). This +/// also affects the normals to the generated polygons. +#[allow(non_camel_case_types)] +pub struct vtkPlaneSource(*mut core::ffi::c_void); +impl vtkPlaneSource { + /// Creates a new [vtkPlaneSource] via `vtkPlaneSource::New()` + #[doc(alias = "vtkPlaneSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPlaneSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPlaneSource_new() }) + } +} +impl std::default::Default for vtkPlaneSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPlaneSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPlaneSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPlaneSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPlaneSource_create_drop() { + let obj = vtkPlaneSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// produce polygonal Platonic solids +/// +/// +/// vtkPlatonicSolidSource can generate each of the five Platonic solids: +/// tetrahedron, cube, octahedron, icosahedron, and dodecahedron. Each of the +/// solids is placed inside a sphere centered at the origin with radius 1.0. +/// To use this class, simply specify the solid to create. Note that this +/// source object creates cell scalars that are (integral value) face numbers. +#[allow(non_camel_case_types)] +pub struct vtkPlatonicSolidSource(*mut core::ffi::c_void); +impl vtkPlatonicSolidSource { + /// Creates a new [vtkPlatonicSolidSource] via `vtkPlatonicSolidSource::New()` + #[doc(alias = "vtkPlatonicSolidSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPlatonicSolidSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPlatonicSolidSource_new() }) + } +} +impl std::default::Default for vtkPlatonicSolidSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPlatonicSolidSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPlatonicSolidSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPlatonicSolidSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPlatonicSolidSource_create_drop() { + let obj = vtkPlatonicSolidSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// handle source used to represent points. +/// +/// +/// vtkPointHandleSource is deriving vtkHandleSource interface. +/// This handle represents a point with its shape being a sphere. +/// Its center and radius can be modified. +/// If the point is also parametered by any direction, it is then +/// represented as a cone pointing in this direction. +#[allow(non_camel_case_types)] +pub struct vtkPointHandleSource(*mut core::ffi::c_void); +impl vtkPointHandleSource { + /// Creates a new [vtkPointHandleSource] via `vtkPointHandleSource::New()` + #[doc(alias = "vtkPointHandleSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPointHandleSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPointHandleSource_new() }) + } +} +impl std::default::Default for vtkPointHandleSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPointHandleSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPointHandleSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPointHandleSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPointHandleSource_create_drop() { + let obj = vtkPointHandleSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a random cloud of points +/// +/// +/// vtkPointSource is a source object that creates a user-specified number +/// of points within a specified radius about a specified center point. +/// By default location of the points is random within the sphere. It is +/// also possible to generate random points only on the surface of the +/// sphere. The output PolyData has the specified number of points and +/// 1 cell - a vtkPolyVertex containing all of the points. +#[allow(non_camel_case_types)] +pub struct vtkPointSource(*mut core::ffi::c_void); +impl vtkPointSource { + /// Creates a new [vtkPointSource] via `vtkPointSource::New()` + #[doc(alias = "vtkPointSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPointSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPointSource_new() }) + } +} +impl std::default::Default for vtkPointSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPointSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPointSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPointSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPointSource_create_drop() { + let obj = vtkPointSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a poly line from a list of input points +/// +/// +/// vtkPolyLineSource is a source object that creates a poly line from +/// user-specified points. The output is a vtkPolyLine. +#[allow(non_camel_case_types)] +pub struct vtkPolyLineSource(*mut core::ffi::c_void); +impl vtkPolyLineSource { + /// Creates a new [vtkPolyLineSource] via `vtkPolyLineSource::New()` + #[doc(alias = "vtkPolyLineSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPolyLineSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPolyLineSource_new() }) + } +} +impl std::default::Default for vtkPolyLineSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPolyLineSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPolyLineSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPolyLineSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPolyLineSource_create_drop() { + let obj = vtkPolyLineSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create points from a list of input points +/// +/// +/// vtkPolyPointSource is a source object that creates a vert from +/// user-specified points. The output is a vtkPolyData. +#[allow(non_camel_case_types)] +pub struct vtkPolyPointSource(*mut core::ffi::c_void); +impl vtkPolyPointSource { + /// Creates a new [vtkPolyPointSource] via `vtkPolyPointSource::New()` + #[doc(alias = "vtkPolyPointSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkPolyPointSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkPolyPointSource_new() }) + } +} +impl std::default::Default for vtkPolyPointSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkPolyPointSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkPolyPointSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkPolyPointSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkPolyPointSource_create_drop() { + let obj = vtkPolyPointSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generate source data object via a user-specified function +/// +/// +/// vtkProgrammableDataObjectSource is a source object that is programmable by +/// the user. The output of the filter is a data object (vtkDataObject) which +/// represents data via an instance of field data. To use this object, you +/// must specify a function that creates the output. +/// +/// Example use of this filter includes reading tabular data and encoding it +/// as vtkFieldData. You can then use filters like vtkDataObjectToDataSetFilter +/// to convert the data object to a dataset and then visualize it. Another +/// important use of this class is that it allows users of interpreters (e.g., +/// Java) the ability to write source objects without having to +/// recompile C++ code or generate new libraries. +/// +/// @sa +/// vtkProgrammableFilter vtkProgrammableAttributeDataFilter +/// vtkProgrammableSource vtkDataObjectToDataSetFilter +#[allow(non_camel_case_types)] +pub struct vtkProgrammableDataObjectSource(*mut core::ffi::c_void); +impl vtkProgrammableDataObjectSource { + /// Creates a new [vtkProgrammableDataObjectSource] via `vtkProgrammableDataObjectSource::New()` + #[doc(alias = "vtkProgrammableDataObjectSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkProgrammableDataObjectSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkProgrammableDataObjectSource_new() }) + } +} +impl std::default::Default for vtkProgrammableDataObjectSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkProgrammableDataObjectSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkProgrammableDataObjectSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkProgrammableDataObjectSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkProgrammableDataObjectSource_create_drop() { + let obj = vtkProgrammableDataObjectSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// generate source dataset via a user-specified function +/// +/// +/// vtkProgrammableSource is a source object that is programmable by the +/// user. To use this object, you must specify a function that creates the +/// output. It is possible to generate an output dataset of any (concrete) +/// type; it is up to the function to properly initialize and define the +/// output. Typically, you use one of the methods to get a concrete output +/// type (e.g., GetPolyDataOutput() or GetStructuredPointsOutput()), and +/// then manipulate the output in the user-specified function. +/// +/// Example use of this include writing a function to read a data file or +/// interface to another system. (You might want to do this in favor of +/// deriving a new class.) Another important use of this class is that it +/// allows users of interpreters (e.g., Java) the ability to write +/// source objects without having to recompile C++ code or generate new +/// libraries. +/// @sa +/// vtkProgrammableFilter vtkProgrammableAttributeDataFilter +/// vtkProgrammableDataObjectSource +#[allow(non_camel_case_types)] +pub struct vtkProgrammableSource(*mut core::ffi::c_void); +impl vtkProgrammableSource { + /// Creates a new [vtkProgrammableSource] via `vtkProgrammableSource::New()` + #[doc(alias = "vtkProgrammableSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkProgrammableSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkProgrammableSource_new() }) + } +} +impl std::default::Default for vtkProgrammableSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkProgrammableSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkProgrammableSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkProgrammableSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkProgrammableSource_create_drop() { + let obj = vtkProgrammableSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Builds a randomized but reproducible vtkHyperTreeGrid. +/// +#[allow(non_camel_case_types)] +pub struct vtkRandomHyperTreeGridSource(*mut core::ffi::c_void); +impl vtkRandomHyperTreeGridSource { + /// Creates a new [vtkRandomHyperTreeGridSource] via `vtkRandomHyperTreeGridSource::New()` + #[doc(alias = "vtkRandomHyperTreeGridSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkRandomHyperTreeGridSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkRandomHyperTreeGridSource_new() }) + } +} +impl std::default::Default for vtkRandomHyperTreeGridSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkRandomHyperTreeGridSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkRandomHyperTreeGridSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkRandomHyperTreeGridSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkRandomHyperTreeGridSource_create_drop() { + let obj = vtkRandomHyperTreeGridSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a rectangular button +/// +/// +/// vtkRectangularButtonSource creates a rectangular shaped button with +/// texture coordinates suitable for application of a texture map. This +/// provides a way to make nice looking 3D buttons. The buttons are +/// represented as vtkPolyData that includes texture coordinates and +/// normals. The button lies in the x-y plane. +/// +/// To use this class you must define its width, height and length. These +/// measurements are all taken with respect to the shoulder of the button. +/// The shoulder is defined as follows. Imagine a box sitting on the floor. +/// The distance from the floor to the top of the box is the depth; the other +/// directions are the length (x-direction) and height (y-direction). In +/// this particular widget the box can have a smaller bottom than top. The +/// ratio in size between bottom and top is called the box ratio (by +/// default=1.0). The ratio of the texture region to the shoulder region +/// is the texture ratio. And finally the texture region may be out of plane +/// compared to the shoulder. The texture height ratio controls this. +/// +/// @sa +/// vtkButtonSource vtkEllipticalButtonSource +/// +/// @warning +/// The button is defined in the x-y plane. Use vtkTransformPolyDataFilter +/// or vtkGlyph3D to orient the button in a different direction. +#[allow(non_camel_case_types)] +pub struct vtkRectangularButtonSource(*mut core::ffi::c_void); +impl vtkRectangularButtonSource { + /// Creates a new [vtkRectangularButtonSource] via `vtkRectangularButtonSource::New()` + #[doc(alias = "vtkRectangularButtonSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkRectangularButtonSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkRectangularButtonSource_new() }) + } +} +impl std::default::Default for vtkRectangularButtonSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkRectangularButtonSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkRectangularButtonSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkRectangularButtonSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkRectangularButtonSource_create_drop() { + let obj = vtkRectangularButtonSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a regular, n-sided polygon and/or polyline +/// +/// +/// vtkRegularPolygonSource is a source object that creates a single n-sided polygon and/or +/// polyline. The polygon is centered at a specified point, orthogonal to +/// a specified normal, and with a circumscribing radius set by the user. The user can +/// also specify the number of sides of the polygon ranging from [3,N]. +/// +/// This object can be used for seeding streamlines or defining regions for clipping/cutting. +#[allow(non_camel_case_types)] +pub struct vtkRegularPolygonSource(*mut core::ffi::c_void); +impl vtkRegularPolygonSource { + /// Creates a new [vtkRegularPolygonSource] via `vtkRegularPolygonSource::New()` + #[doc(alias = "vtkRegularPolygonSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkRegularPolygonSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkRegularPolygonSource_new() }) + } +} +impl std::default::Default for vtkRegularPolygonSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkRegularPolygonSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkRegularPolygonSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkRegularPolygonSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkRegularPolygonSource_create_drop() { + let obj = vtkRegularPolygonSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Generate selection from given set of ids +/// +/// vtkSelectionSource generates a vtkSelection from a set of +/// (piece id, cell id) pairs. It will only generate the selection values +/// that match UPDATE_PIECE_NUMBER (i.e. piece == UPDATE_PIECE_NUMBER). +/// +/// User-supplied, application-specific selections (with a ContentType of +/// vtkSelectionNode::USER) are not supported. +#[allow(non_camel_case_types)] +pub struct vtkSelectionSource(*mut core::ffi::c_void); +impl vtkSelectionSource { + /// Creates a new [vtkSelectionSource] via `vtkSelectionSource::New()` + #[doc(alias = "vtkSelectionSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkSelectionSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkSelectionSource_new() }) + } +} +impl std::default::Default for vtkSelectionSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkSelectionSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkSelectionSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkSelectionSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkSelectionSource_create_drop() { + let obj = vtkSelectionSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a polygonal sphere centered at the origin +/// +/// +/// vtkSphereSource creates a sphere (represented by polygons) of specified +/// radius centered at the origin. The resolution (polygonal discretization) +/// in both the latitude (phi) and longitude (theta) directions can be +/// specified. It also is possible to create partial spheres by specifying +/// maximum phi and theta angles. By default, the surface tessellation of +/// the sphere uses triangles; however you can set LatLongTessellation to +/// produce a tessellation using quadrilaterals. +/// +/// @warning +/// Resolution means the number of latitude or longitude lines for a complete +/// sphere. If you create partial spheres the number of latitude/longitude +/// lines may be off by one. +#[allow(non_camel_case_types)] +pub struct vtkSphereSource(*mut core::ffi::c_void); +impl vtkSphereSource { + /// Creates a new [vtkSphereSource] via `vtkSphereSource::New()` + #[doc(alias = "vtkSphereSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkSphereSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkSphereSource_new() }) + } +} +impl std::default::Default for vtkSphereSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkSphereSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkSphereSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkSphereSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkSphereSource_create_drop() { + let obj = vtkSphereSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a polygonal superquadric centered +/// +/// at the origin +/// +/// vtkSuperquadricSource creates a superquadric (represented by polygons) of +/// specified size centered at the origin. The alignment of the axis of the +/// superquadric along one of the global axes can be specified. The resolution +/// (polygonal discretization) +/// in both the latitude (phi) and longitude (theta) directions can be +/// specified. Roundness parameters (PhiRoundness and ThetaRoundness) control +/// the shape of the superquadric. The Toroidal boolean controls whether +/// a toroidal superquadric is produced. If so, the Thickness parameter +/// controls the thickness of the toroid: 0 is the thinnest allowable +/// toroid, and 1 has a minimum sized hole. The Scale parameters allow +/// the superquadric to be scaled in x, y, and z (normal vectors are correctly +/// generated in any case). The Size parameter controls size of the +/// superquadric. +/// +/// This code is based on "Rigid physically based superquadrics", A. H. Barr, +/// in "Graphics Gems III", David Kirk, ed., Academic Press, 1992. +/// +/// @warning +/// Resolution means the number of latitude or longitude lines for a complete +/// superquadric. The resolution parameters are rounded to the nearest 4 +/// in phi and 8 in theta. +/// +/// @warning +/// Texture coordinates are not equally distributed around all superquadrics. +/// +/// @warning +/// The Size and Thickness parameters control coefficients of superquadric +/// generation, and may do not exactly describe the size of the superquadric. +#[allow(non_camel_case_types)] +pub struct vtkSuperquadricSource(*mut core::ffi::c_void); +impl vtkSuperquadricSource { + /// Creates a new [vtkSuperquadricSource] via `vtkSuperquadricSource::New()` + #[doc(alias = "vtkSuperquadricSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkSuperquadricSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkSuperquadricSource_new() }) + } +} +impl std::default::Default for vtkSuperquadricSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkSuperquadricSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkSuperquadricSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkSuperquadricSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkSuperquadricSource_create_drop() { + let obj = vtkSuperquadricSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Create a polygonal representation of a box +/// +/// with a given level of subdivision. +/// +/// vtkTessellatedBoxSource creates a axis-aligned box defined by its bounds +/// and a level of subdivision. Connectivity is strong: points of the vertices +/// and inside the edges are shared between faces. In other words, faces are +/// connected. Each face looks like a grid of quads, each quad is composed of +/// 2 triangles. +/// Given a level of subdivision `l', each edge has `l'+2 points, `l' of them +/// are internal edge points, the 2 other ones are the vertices. +/// Each face has a total of (`l'+2)*(`l'+2) points, 4 of them are vertices, +/// 4*`l' are internal edge points, it remains `l'^2 internal face points. +/// +/// This source only generate geometry, no DataArrays like normals or texture +/// coordinates. +#[allow(non_camel_case_types)] +pub struct vtkTessellatedBoxSource(*mut core::ffi::c_void); +impl vtkTessellatedBoxSource { + /// Creates a new [vtkTessellatedBoxSource] via `vtkTessellatedBoxSource::New()` + #[doc(alias = "vtkTessellatedBoxSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkTessellatedBoxSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkTessellatedBoxSource_new() }) + } +} +impl std::default::Default for vtkTessellatedBoxSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkTessellatedBoxSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkTessellatedBoxSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkTessellatedBoxSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkTessellatedBoxSource_create_drop() { + let obj = vtkTessellatedBoxSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create polygonal text +/// +/// +/// vtkTextSource converts a text string into polygons. This way you can +/// insert text into your renderings. It uses the 9x15 font from X Windows. +/// You can specify if you want the background to be drawn or not. The +/// characters are formed by scan converting the raster font into +/// quadrilaterals. Colors are assigned to the letters using scalar data. +/// To set the color of the characters with the source's actor property, set +/// BackingOff on the text source and ScalarVisibilityOff on the associated +/// vtkPolyDataMapper. Then, the color can be set using the associated actor's +/// property. +/// +/// vtkVectorText generates higher quality polygonal representations of +/// characters. +/// +/// @sa +/// vtkVectorText +#[allow(non_camel_case_types)] +pub struct vtkTextSource(*mut core::ffi::c_void); +impl vtkTextSource { + /// Creates a new [vtkTextSource] via `vtkTextSource::New()` + #[doc(alias = "vtkTextSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkTextSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkTextSource_new() }) + } +} +impl std::default::Default for vtkTextSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkTextSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkTextSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkTextSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkTextSource_create_drop() { + let obj = vtkTextSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// create a sphere centered at the origin +/// +/// +/// vtkTexturedSphereSource creates a polygonal sphere of specified radius +/// centered at the origin. The resolution (polygonal discretization) in both +/// the latitude (phi) and longitude (theta) directions can be specified. +/// It also is possible to create partial sphere by specifying maximum phi and +/// theta angles. +#[allow(non_camel_case_types)] +pub struct vtkTexturedSphereSource(*mut core::ffi::c_void); +impl vtkTexturedSphereSource { + /// Creates a new [vtkTexturedSphereSource] via `vtkTexturedSphereSource::New()` + #[doc(alias = "vtkTexturedSphereSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkTexturedSphereSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkTexturedSphereSource_new() }) + } +} +impl std::default::Default for vtkTexturedSphereSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkTexturedSphereSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkTexturedSphereSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkTexturedSphereSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkTexturedSphereSource_create_drop() { + let obj = vtkTexturedSphereSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +} +/// Create a synthetic grid of uniform hypertrees. +/// +/// +/// This class uses input parameters, most notably a string descriptor, +/// to generate a vtkHyperTreeGrid instance representing the corresponding +/// tree-based AMR grid with uniform root cell sizes along each axis. +/// +/// @sa +/// vtkHyperTreeGridSource vtkUniformHyperTreeGrid +/// +/// @par Thanks: +/// This class was written by Philippe Pebay, NexGen Analytics 2017 +/// This work was supported by Commissariat a l'Energie Atomique (CEA/DIF) +/// CEA, DAM, DIF, F-91297 Arpajon, France. +#[allow(non_camel_case_types)] +pub struct vtkUniformHyperTreeGridSource(*mut core::ffi::c_void); +impl vtkUniformHyperTreeGridSource { + /// Creates a new [vtkUniformHyperTreeGridSource] via `vtkUniformHyperTreeGridSource::New()` + #[doc(alias = "vtkUniformHyperTreeGridSource")] + pub fn new() -> Self { + unsafe extern "C" { + fn vtkUniformHyperTreeGridSource_new() -> *mut core::ffi::c_void; + } + Self(unsafe { vtkUniformHyperTreeGridSource_new() }) + } +} +impl std::default::Default for vtkUniformHyperTreeGridSource { + fn default() -> Self { + Self::new() + } +} +impl Drop for vtkUniformHyperTreeGridSource { + fn drop(&mut self) { + unsafe extern "C" { + fn vtkUniformHyperTreeGridSource_destructor(sself: *mut core::ffi::c_void); + } + unsafe { vtkUniformHyperTreeGridSource_destructor(self.0) } + self.0 = core::ptr::null_mut(); + } +} +#[test] +fn test_vtkUniformHyperTreeGridSource_create_drop() { + let obj = vtkUniformHyperTreeGridSource::new(); + assert!(!obj.0.is_null()); + drop(obj); +}