#pragma once
#include <string>

struct Foo{
  Foo();
  Foo(std::string const& s);
  void doSomething();
  std::string m_string;
};

#include "foo.h"
#include <iostream>

Foo::Foo() {}

Foo::Foo(std::string const& s) : m_string(s) {}

void Foo::doSomething() {
  std::cout << "Foo:" << m_string << std::endl;
}

%module module
%{
  #include "foo.h"
%}

%include "std_string.i"
%include "foo.h"

swig -python -c++ -Wall foo.i
swig -python -c++ -Wall -external-runtime runtime.h

g++ -fPIC -Wall -Wextra -shared -o _module.so foo_wrap.cxx foo.cpp -I/usr/include/python2.7 -lpython2.7

#include "foo.h"
#include <Python.h>
#include "runtime.h"

int main(int argc, char **argv) {
  Py_Initialize();

  PyObject* syspath = PySys_GetObject((char*)"path");
  PyObject* pName = PyString_FromString((char*) ".");
  int err = PyList_Insert(syspath, 0, pName);
  Py_DECREF(pName);

  err = PySys_SetObject((char*) "path", syspath);

  PyObject *main, *module, *pInstance, *run, *setup;

  try {
    main = PyImport_ImportModule("__main__");
    err = PyRun_SimpleString(
        "a_foo = None\n"
        "\n"
        "def setup(a_foo_from_cxx):\n"
        "    print 'setup called with', a_foo_from_cxx\n"
        "    global a_foo\n"
        "    a_foo = a_foo_from_cxx\n"
        "\n"
        "def run():\n"
        "    a_foo.doSomething()\n"
        "\n"
        "print 'main module loaded'\n");

    // Load Python module
    module = PyImport_ImportModule("module");

    swig_type_info *pTypeInfo = nullptr;
    pTypeInfo = SWIG_TypeQuery("Foo *");

    Foo* pFoo = new Foo("Hello");
    int owned = 1;
    pInstance =
        SWIG_NewPointerObj(reinterpret_cast<void*>(pFoo), pTypeInfo, owned);

    setup = PyObject_GetAttrString(main, "setup");

    PyObject* result = PyObject_CallFunctionObjArgs(setup, pInstance, NULL);
    Py_DECREF(result);

    run = PyObject_GetAttrString(main, "run");

    result = PyObject_CallFunctionObjArgs(run, NULL);
    Py_DECREF(result);
  }
  catch (...) {
    PyErr_Print();
  }

  Py_DECREF(run);
  Py_DECREF(setup);
  Py_DECREF(pInstance);
  Py_DECREF(module);
  Py_DECREF(main);

  Py_Finalize();
  return 0;
}

g++ -Wall -Wextra -I/usr/include/python2.7 main.cpp foo.cpp -o main -lpython2.7

void CopyImage(mitk::Image *image)
{
  PyGILState_STATE gState = PyGILState_Ensure();
  PyObject *main = PyImport_ImportModule("__main__");

  int err = PyRun_SimpleString("import pyMITK\n"
                               "image = None\n"
                               "\n"
                               "def setup(image_from_cxx):\n"
                               "    print ('setup called with', image_from_cxx)\n"
                               "    global image\n"
                               "    image = image_from_cxx\n"
                               "\n"
                               "def run():\n"
                               "    nr_of_dimensions = image.GetDimension()\n"
                               "    print(str(nr_of_dimensions))\n"
                               "\n"
                               "print ('main module loaded')\n");

  swig_type_info *pTypeInfo = nullptr;
  pTypeInfo = SWIG_TypeQuery("_p_mitk__Image");
  int owned = 0;
  PyObject *pInstance = SWIG_NewPointerObj(reinterpret_cast<void *>(image), pTypeInfo, owned);

  PyObject *setup = PyObject_GetAttrString(main, "setup");
  PyObject *result = PyObject_CallFunctionObjArgs(setup, pInstance, NULL);

  PyObject *run = PyObject_GetAttrString(main, "run");
  result = PyObject_CallFunctionObjArgs(run, NULL);

  m_ThreadState = PyEval_SaveThread();
}

AttributeError: 'SwigPyObject' object has no attribute 'GetDimension'

<Swig Object of type 'std::vector< mitk::Image * >::value_type' at 0x0000027C30E3B2A0>

<pyMITK.ImagePointer; proxy of <Swig Object of type 'mitk::Image::Pointer *' at 0x00000245250352D0> >