vtkImageViewer2_c.cpp

Content is user-generated and unverified.
#include "vtkImageViewer2_c.h"
#include <vtkImageViewer2.h>
#include <vtkImageData.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkImageActor.h>
#include <vtkImageMapToWindowLevelColors.h>
#include <vtkInteractorStyleImage.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkAlgorithmOutput.h>
#include <iostream>
#include <string>

/* Internal structure to wrap VTK C++ object */
struct vtkImageViewer2_C {
    vtkImageViewer2* vtk_object;
    
    vtkImageViewer2_C() : vtk_object(nullptr) {}
    ~vtkImageViewer2_C() {
        if (vtk_object) {
            vtk_object->Delete();
        }
    }
};

/* Similar wrapper structures for other VTK objects */
struct vtkImageData_C { vtkImageData* vtk_object; };
struct vtkRenderWindow_C { vtkRenderWindow* vtk_object; };
struct vtkRenderer_C { vtkRenderer* vtk_object; };
struct vtkImageActor_C { vtkImageActor* vtk_object; };
struct vtkImageMapToWindowLevelColors_C { vtkImageMapToWindowLevelColors* vtk_object; };
struct vtkInteractorStyleImage_C { vtkInteractorStyleImage* vtk_object; };
struct vtkRenderWindowInteractor_C { vtkRenderWindowInteractor* vtk_object; };
struct vtkAlgorithmOutput_C { vtkAlgorithmOutput* vtk_object; };

/* Helper macros for null checking */
#define CHECK_NULL_RETURN(obj, retval) if (!obj || !obj->vtk_object) return retval
#define CHECK_NULL_RETURN_VOID(obj) if (!obj || !obj->vtk_object) return

/* Object lifetime management */
vtkImageViewer2_C* vtkImageViewer2_New(void) {
    vtkImageViewer2_C* wrapper = new vtkImageViewer2_C();
    wrapper->vtk_object = vtkImageViewer2::New();
    return wrapper;
}

void vtkImageViewer2_Delete(vtkImageViewer2_C* self) {
    if (self) {
        delete self;
    }
}

/* Basic rendering */
void vtkImageViewer2_Render(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->Render();
}

const char* vtkImageViewer2_GetWindowName(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    return self->vtk_object->GetWindowName();
}

/* Input data management */
void vtkImageViewer2_SetInputData(vtkImageViewer2_C* self, vtkImageData_C* input) {
    CHECK_NULL_RETURN_VOID(self);
    if (input && input->vtk_object) {
        self->vtk_object->SetInputData(input->vtk_object);
    }
}

vtkImageData_C* vtkImageViewer2_GetInput(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    vtkImageData* input = self->vtk_object->GetInput();
    if (!input) return nullptr;
    
    vtkImageData_C* wrapper = new vtkImageData_C();
    wrapper->vtk_object = input;
    return wrapper;
}

void vtkImageViewer2_SetInputConnection(vtkImageViewer2_C* self, vtkAlgorithmOutput_C* input) {
    CHECK_NULL_RETURN_VOID(self);
    if (input && input->vtk_object) {
        self->vtk_object->SetInputConnection(input->vtk_object);
    }
}

/* Slice orientation */
int vtkImageViewer2_GetSliceOrientation(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0);
    return self->vtk_object->GetSliceOrientation();
}

void vtkImageViewer2_SetSliceOrientation(vtkImageViewer2_C* self, int orientation) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetSliceOrientation(orientation);
}

void vtkImageViewer2_SetSliceOrientationToXY(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetSliceOrientationToXY();
}

void vtkImageViewer2_SetSliceOrientationToYZ(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetSliceOrientationToYZ();
}

void vtkImageViewer2_SetSliceOrientationToXZ(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetSliceOrientationToXZ();
}

/* Slice management */
int vtkImageViewer2_GetSlice(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0);
    return self->vtk_object->GetSlice();
}

void vtkImageViewer2_SetSlice(vtkImageViewer2_C* self, int slice) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetSlice(slice);
}

void vtkImageViewer2_UpdateDisplayExtent(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->UpdateDisplayExtent();
}

/* Slice range information */
int vtkImageViewer2_GetSliceMin(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0);
    return self->vtk_object->GetSliceMin();
}

int vtkImageViewer2_GetSliceMax(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0);
    return self->vtk_object->GetSliceMax();
}

void vtkImageViewer2_GetSliceRange(vtkImageViewer2_C* self, int range[2]) {
    CHECK_NULL_RETURN_VOID(self);
    if (range) {
        self->vtk_object->GetSliceRange(range);
    }
}

void vtkImageViewer2_GetSliceRangeMinMax(vtkImageViewer2_C* self, int* min, int* max) {
    CHECK_NULL_RETURN_VOID(self);
    if (min && max) {
        self->vtk_object->GetSliceRange(*min, *max);
    }
}

int* vtkImageViewer2_GetSliceRangePtr(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    return self->vtk_object->GetSliceRange();
}

/* Color window/level */
double vtkImageViewer2_GetColorWindow(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0.0);
    return self->vtk_object->GetColorWindow();
}

double vtkImageViewer2_GetColorLevel(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0.0);
    return self->vtk_object->GetColorLevel();
}

void vtkImageViewer2_SetColorWindow(vtkImageViewer2_C* self, double window) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetColorWindow(window);
}

void vtkImageViewer2_SetColorLevel(vtkImageViewer2_C* self, double level) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetColorLevel(level);
}

/* Window management */
void vtkImageViewer2_SetDisplayId(vtkImageViewer2_C* self, void* display_id) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetDisplayId(display_id);
}

void vtkImageViewer2_SetWindowId(vtkImageViewer2_C* self, void* window_id) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetWindowId(window_id);
}

void vtkImageViewer2_SetParentId(vtkImageViewer2_C* self, void* parent_id) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetParentId(parent_id);
}

/* Position and size */
int* vtkImageViewer2_GetPosition(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    return self->vtk_object->GetPosition();
}

void vtkImageViewer2_SetPosition(vtkImageViewer2_C* self, int x, int y) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetPosition(x, y);
}

void vtkImageViewer2_SetPositionArray(vtkImageViewer2_C* self, int pos[2]) {
    CHECK_NULL_RETURN_VOID(self);
    if (pos) {
        self->vtk_object->SetPosition(pos);
    }
}

int* vtkImageViewer2_GetSize(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    return self->vtk_object->GetSize();
}

void vtkImageViewer2_SetSize(vtkImageViewer2_C* self, int width, int height) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetSize(width, height);
}

void vtkImageViewer2_SetSizeArray(vtkImageViewer2_C* self, int size[2]) {
    CHECK_NULL_RETURN_VOID(self);
    if (size) {
        self->vtk_object->SetSize(size);
    }
}

/* Component access */
vtkRenderWindow_C* vtkImageViewer2_GetRenderWindow(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    vtkRenderWindow* window = self->vtk_object->GetRenderWindow();
    if (!window) return nullptr;
    
    vtkRenderWindow_C* wrapper = new vtkRenderWindow_C();
    wrapper->vtk_object = window;
    return wrapper;
}

vtkRenderer_C* vtkImageViewer2_GetRenderer(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    vtkRenderer* renderer = self->vtk_object->GetRenderer();
    if (!renderer) return nullptr;
    
    vtkRenderer_C* wrapper = new vtkRenderer_C();
    wrapper->vtk_object = renderer;
    return wrapper;
}

vtkImageActor_C* vtkImageViewer2_GetImageActor(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    vtkImageActor* actor = self->vtk_object->GetImageActor();
    if (!actor) return nullptr;
    
    vtkImageActor_C* wrapper = new vtkImageActor_C();
    wrapper->vtk_object = actor;
    return wrapper;
}

vtkImageMapToWindowLevelColors_C* vtkImageViewer2_GetWindowLevel(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    vtkImageMapToWindowLevelColors* windowLevel = self->vtk_object->GetWindowLevel();
    if (!windowLevel) return nullptr;
    
    vtkImageMapToWindowLevelColors_C* wrapper = new vtkImageMapToWindowLevelColors_C();
    wrapper->vtk_object = windowLevel;
    return wrapper;
}

vtkInteractorStyleImage_C* vtkImageViewer2_GetInteractorStyle(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    vtkInteractorStyleImage* style = self->vtk_object->GetInteractorStyle();
    if (!style) return nullptr;
    
    vtkInteractorStyleImage_C* wrapper = new vtkInteractorStyleImage_C();
    wrapper->vtk_object = style;
    return wrapper;
}

/* Component setup */
void vtkImageViewer2_SetRenderWindow(vtkImageViewer2_C* self, vtkRenderWindow_C* window) {
    CHECK_NULL_RETURN_VOID(self);
    if (window && window->vtk_object) {
        self->vtk_object->SetRenderWindow(window->vtk_object);
    }
}

void vtkImageViewer2_SetRenderer(vtkImageViewer2_C* self, vtkRenderer_C* renderer) {
    CHECK_NULL_RETURN_VOID(self);
    if (renderer && renderer->vtk_object) {
        self->vtk_object->SetRenderer(renderer->vtk_object);
    }
}

void vtkImageViewer2_SetupInteractor(vtkImageViewer2_C* self, vtkRenderWindowInteractor_C* interactor) {
    CHECK_NULL_RETURN_VOID(self);
    if (interactor && interactor->vtk_object) {
        self->vtk_object->SetupInteractor(interactor->vtk_object);
    }
}

/* Off-screen rendering */
int vtkImageViewer2_GetOffScreenRendering(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0);
    return self->vtk_object->GetOffScreenRendering();
}

void vtkImageViewer2_SetOffScreenRendering(vtkImageViewer2_C* self, int enable) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetOffScreenRendering(enable);
}

void vtkImageViewer2_OffScreenRenderingOn(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->OffScreenRenderingOn();
}

void vtkImageViewer2_OffScreenRenderingOff(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->OffScreenRenderingOff();
}

/* Type checking */
int vtkImageViewer2_IsTypeOf(const char* type) {
    if (!type) return 0;
    return vtkImageViewer2::IsTypeOf(type);
}

int vtkImageViewer2_IsA(vtkImageViewer2_C* self, const char* type) {
    CHECK_NULL_RETURN(self, 0);
    if (!type) return 0;
    return self->vtk_object->IsA(type);
}

/* Object information */
const char* vtkImageViewer2_GetClassName(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    return self->vtk_object->GetClassName();
}

void vtkImageViewer2_PrintSelf(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->PrintSelf(std::cout, vtkIndent());
}

/* Reference counting */
int vtkImageViewer2_GetReferenceCount(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0);
    return self->vtk_object->GetReferenceCount();
}

void vtkImageViewer2_Register(vtkImageViewer2_C* self, void* object) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->Register(static_cast<vtkObjectBase*>(object));
}

void vtkImageViewer2_UnRegister(vtkImageViewer2_C* self, void* object) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->UnRegister(static_cast<vtkObjectBase*>(object));
}

/* Debug support */
int vtkImageViewer2_GetDebug(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0);
    return self->vtk_object->GetDebug() ? 1 : 0;
}

void vtkImageViewer2_SetDebug(vtkImageViewer2_C* self, int debug_flag) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->SetDebug(debug_flag != 0);
}

void vtkImageViewer2_DebugOn(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->DebugOn();
}

void vtkImageViewer2_DebugOff(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->DebugOff();
}

/* Modification time */
unsigned long vtkImageViewer2_GetMTime(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, 0);
    return self->vtk_object->GetMTime();
}

void vtkImageViewer2_Modified(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN_VOID(self);
    self->vtk_object->Modified();
}

/* Global warning display */
int vtkImageViewer2_GetGlobalWarningDisplay(void) {
    return vtkObject::GetGlobalWarningDisplay();
}

void vtkImageViewer2_SetGlobalWarningDisplay(int val) {
    vtkObject::SetGlobalWarningDisplay(val);
}

void vtkImageViewer2_GlobalWarningDisplayOn(void) {
    vtkObject::GlobalWarningDisplayOn();
}

void vtkImageViewer2_GlobalWarningDisplayOff(void) {
    vtkObject::GlobalWarningDisplayOff();
}

/* Object name and description */
void vtkImageViewer2_SetObjectName(vtkImageViewer2_C* self, const char* name) {
    CHECK_NULL_RETURN_VOID(self);
    if (name) {
        self->vtk_object->SetObjectName(std::string(name));
    }
}

const char* vtkImageViewer2_GetObjectName(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    static std::string name_storage;
    name_storage = self->vtk_object->GetObjectName();
    return name_storage.c_str();
}

const char* vtkImageViewer2_GetObjectDescription(vtkImageViewer2_C* self) {
    CHECK_NULL_RETURN(self, nullptr);
    static std::string desc_storage;
    desc_storage = self->vtk_object->GetObjectDescription();
    return desc_storage.c_str();
}
Content is user-generated and unverified.