PyObject* py_snapshot(PyObject* self, PyObject* args) {
static PythonParameterParser tester(1);
std::string filename, canvasName = "";
if (tester.parse(args, filename, canvasName)== -1) {
return nullptr;
}
CanvasProcessor* canvas = nullptr;
if (canvasName.size() != 0) {
canvas = dynamic_cast<CanvasProcessor*>(
InviwoApplication::getPtr()->getProcessorNetwork()->getProcessorByIdentifier(
canvasName));
} else {
if (InviwoApplication::getPtr() && InviwoApplication::getPtr()->getProcessorNetwork()) {
std::vector<CanvasProcessor*> canvases = InviwoApplication::getPtr()
->getProcessorNetwork()
->getProcessorsByType<CanvasProcessor>();
if (canvases.size() != 0)
canvas = InviwoApplication::getPtr()
->getProcessorNetwork()
->getProcessorsByType<CanvasProcessor>()[0];
}
}
if (!canvas) {
PyErr_SetString(PyExc_TypeError, "snapshot() no canvas found");
return nullptr;
}
canvas->saveImageLayer(filename.c_str());
Py_RETURN_NONE;
}
PyObject* py_showTransferFunctionEditor(PyObject* self, PyObject* args) {
static PythonParameterParser tester;
std::string path;
if (tester.parse(args, path) == -1) {
return nullptr;
}
Property* theProperty =
InviwoApplication::getPtr()->getProcessorNetwork()->getProperty(splitString(path, '.'));
if (!theProperty) {
std::string msg =
std::string("showTransferFunctionEditor() no property with path: ") + path;
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
if (!dynamic_cast<TransferFunctionProperty*>(theProperty)) {
std::string msg =
std::string("showTransferFunctionEditor() not a transfer function property: ") +
theProperty->getClassIdentifier();
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
for (auto w : theProperty->getWidgets()) {
auto tfw = dynamic_cast<TransferFunctionPropertyWidgetQt*>(w);
if (tfw) {
tfw->openTransferFunctionDialog();
}
}
Py_RETURN_NONE;
}
PyObject* py_loadTransferFunction(PyObject* /*self*/, PyObject* args) {
static PythonParameterParser tester;
std::string path;
std::string filename;
if (tester.parse(args, path, filename) == -1) {
return nullptr;
}
auto tf = getTF(path, "loadTransferFunction");
if (!tf) { return nullptr; }
auto app = InviwoApplication::getPtr();
if (!filesystem::fileExists(filename)) {
if (filesystem::fileExists(app->getPath(PathType::TransferFunctions, "/" + filename))) {
filename = app->getPath(PathType::TransferFunctions, "/" + filename);
} else {
std::string msg = "loadTransferFunction() file not found (" + filename + ")";
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
}
Deserializer deserializer(app, filename);
tf->deserialize(deserializer);
Py_RETURN_NONE;
}
PyObject* py_update(PyObject* self, PyObject* args) {
static PythonParameterParser tester;
if (tester.parse(args) == -1) {
return nullptr;
}
if (auto qt = dynamic_cast<InviwoApplicationQt*>(InviwoApplication::getPtr())) {
qt->processEvents();
}
Py_RETURN_NONE;
}
PyObject* py_getPathCurrentWorkspace(PyObject* self, PyObject* args) {
static PythonParameterParser tester;
if (tester.parse(args) == -1) {
return nullptr;
}
if (auto qt = dynamic_cast<InviwoApplicationQt*>(InviwoApplication::getPtr())) {
if (auto mw = dynamic_cast<InviwoMainWindow*>(qt->getMainWindow())) {
return PyValueParser::toPyObject(mw->getNetworkEditor()->getCurrentFilename());
}
}
return nullptr;
}
PyObject* py_quitInviwo(PyObject* self, PyObject* args) {
static PythonParameterParser tester;
if (tester.parse(args) == -1) {
return nullptr;
}
if (auto qt = dynamic_cast<InviwoApplicationQt*>(InviwoApplication::getPtr())) {
if (auto mw = dynamic_cast<InviwoMainWindow*>(qt->getMainWindow())) {
mw->getNetworkEditor()->setModified(false);
mw->close();
}
}
Py_RETURN_NONE;
}
PyObject* py_clearTransferfunction(PyObject* /*self*/, PyObject* args) {
static PythonParameterParser tester;
std::string path;
if (tester.parse(args, path) == -1) {
return nullptr;
}
auto tf = getTF(path, "clearTransferfunction");
if (!tf) { return nullptr; }
tf->get().clearPoints();
Py_RETURN_NONE;
}
PyObject* py_getModulePath(PyObject* self, PyObject* args) {
static PythonParameterParser tester;
std::string name;
if (tester.parse(args, name) == -1) {
return nullptr;
}
if (auto module = InviwoApplication::getPtr()->getModuleByIdentifier(name)) {
return PyValueParser::toPyObject(module->getPath());
} else {
auto err = "Could not find a module with id: " + name;
PyErr_SetString(PyExc_TypeError, err.c_str());
return nullptr;
}
}
PyObject* py_saveWorkspace(PyObject* self, PyObject* args) {
static PythonParameterParser tester(1);
std::string filename;
bool setAsFilename;
if (tester.parse(args, filename , setAsFilename) == -1) {
return nullptr;
}
if (auto qt = dynamic_cast<InviwoApplicationQt*>(InviwoApplication::getPtr())) {
if (auto mw = dynamic_cast<InviwoMainWindow*>(qt->getMainWindow())) {
filename = filesystem::cleanupPath(filename);
mw->getNetworkEditor()->saveNetwork(filename, setAsFilename);
}
}
Py_RETURN_NONE;
}
PyObject* py_saveTransferFunction(PyObject* /*self*/, PyObject* args) {
static PythonParameterParser tester;
std::string path;
std::string filename;
if (tester.parse(args,path,filename) == -1) {
return nullptr;
}
auto tf = getTF(path,"saveTransferFunction");
if (!tf) { return nullptr; }
Serializer serializer(filename);
tf->serialize(serializer);
serializer.writeFile();
Py_RETURN_NONE;
}
PyObject* py_addPointTransferFunction(PyObject* /*self*/, PyObject* args) {
static PythonParameterParser tester;
std::string path;
vec2 pos;
vec3 color;
if (tester.parse(args, path, pos, color) == -1) {
return nullptr;
}
auto tf = getTF(path, "addPointTransferFunction");
if (!tf) { return nullptr; }
tf->get().addPoint(pos, vec4(color, pos.y));
tf->setModified(true);
Py_RETURN_NONE;
}
PyObject* py_prompt(PyObject* self, PyObject* args) {
static PythonParameterParser tester(1);
std::string title, message, defaultValue = "";
if (tester.parse(args, title, message, defaultValue) == -1) {
return nullptr;
}
bool ok;
QString text = QInputDialog::getText(nullptr, title.c_str(), message.c_str(), QLineEdit::Normal,
defaultValue.c_str(), &ok);
if (ok && !text.isEmpty()) {
std::string t = text.toLocal8Bit().constData();
return PyValueParser::toPyObject(t);
} else if (ok) {
return PyValueParser::toPyObject(std::string(""));
}
Py_RETURN_NONE;
}
PyObject* py_snapshotAllCanvases(PyObject* self, PyObject* args) {
static PythonParameterParser tester(2);
std::string path, prefix = "", fileEnding = "png";
if (tester.parse(args, path, prefix, fileEnding) == -1) {
return nullptr;
}
std::vector<CanvasProcessor*> canvases =
InviwoApplication::getPtr()->getProcessorNetwork()->getProcessorsByType<CanvasProcessor>();
for (auto& c : canvases) {
std::stringstream ss;
ss << path << "/" << prefix << c->getIdentifier() << "." << fileEnding;
c->saveImageLayer(ss.str());
}
Py_RETURN_NONE;
}
PyObject* py_snapshotCanvas(PyObject* self, PyObject* args) {
static PythonParameterParser tester;
int index;
std::string filename;
if (tester.parse(args, index, filename)== -1) {
return nullptr;
}
std::vector<CanvasProcessor*> canvases =
InviwoApplication::getPtr()->getProcessorNetwork()->getProcessorsByType<CanvasProcessor>();
if (index >= static_cast<int>(canvases.size())) {
std::string msg = std::string("snapshotCanvas() index out of range with index: ") +
toString(index) + " ,canvases avilable: " + toString(canvases.size());
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
canvases[index]->saveImageLayer(filename);
Py_RETURN_NONE;
}
PyObject* py_loadWorkspace(PyObject* self, PyObject* args) {
static PythonParameterParser tester;
std::string filename;
if (tester.parse(args, filename) == -1) {
return nullptr;
}
if (!filesystem::fileExists(filename)) {
filename = filesystem::getPath(PathType::Workspaces) + "/" + filename;
if (!filesystem::fileExists(filename)) {
std::string msg = std::string("loadWorkspace() could not find file") + filename;
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
}
if (auto qt = dynamic_cast<InviwoApplicationQt*>(InviwoApplication::getPtr())) {
if (auto mw = dynamic_cast<InviwoMainWindow*>(qt->getMainWindow())) {
mw->getNetworkEditor()->loadNetwork(filename);
}
}
Py_RETURN_NONE;
}
PyObject* py_resizecanvas(PyObject* /*self*/, PyObject* args) {
static PythonParameterParser tester;
PyObject* arg0;
int w;
int h;
if (tester.parse(args,arg0, w, h) == -1) {
return nullptr;
}
CanvasProcessor* canvas = nullptr;
bool argIsString = PyValueParser::is<std::string>(arg0);
if (argIsString) {
std::string id = PyValueParser::parse<std::string>(arg0);
Processor* processor =
InviwoApplication::getPtr()->getProcessorNetwork()->getProcessorByIdentifier(id);
if (!processor) {
std::string msg =
std::string("resizeCanvas(canvas,width,height) no processor with name: ") + id;
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
canvas = dynamic_cast<CanvasProcessor*>(processor);
if (!canvas) {
std::string msg =
std::string("resizeCanvas(canvas,width,height) processor with name: ") + id +
" is not a canvas processor, it is a" + processor->getClassIdentifier();
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
} else {
int id = PyValueParser::parse<int>(arg0);
std::vector<CanvasProcessor*> canvases = InviwoApplication::getPtr()
->getProcessorNetwork()
->getProcessorsByType<CanvasProcessor>();
if (canvases.size() == 0) {
std::string msg = std::string(
"resizeCanvas(canvas,width,height) no canvases found in current network");
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
if (static_cast<int>(canvases.size()) <= id) {
std::string msg =
std::string(
"resizeCanvas(canvas,width,height) index out of bounds, index given: ") +
toString(id) + ", max index possible: " + toString(canvases.size() - 1);
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
canvas = canvases[id];
}
if (w <= 0 || h <= 0) {
std::string msg = std::string(
"resizeCanvas(canvas,width,height) width and height must have positive non-zero "
"values");
PyErr_SetString(PyExc_TypeError, msg.c_str());
return nullptr;
}
canvas->setCanvasSize(ivec2(w, h));
//canvas->invalidate(InvalidationLevel::InvalidOutput);
Py_RETURN_NONE;
}
