pythonQtConversion.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2016, Institut fuer Technische Optik (ITO),
    Universitaet Stuttgart, Germany

    This file is part of itom.
  
    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.

    itom is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
    General Public Licence for more details.

    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */

#ifndef PYTHONQTCONVERSION_H
#define PYTHONQTCONVERSION_H

#include "pythonDataObject.h"
#include "pythonPlugins.h"
#include "pythonRegion.h"
#include "pythonPCL.h"
#include "pythonAutoInterval.h"
#include "pythonNone.h"
#include "datetime.h"

#include "../global.h"
#include "../../common/itomPlotHandle.h"
#include "../../common/shape.h"

#include "opencv/cv.h"
#include <qvariant.h>
#include <qmetaobject.h>
#include <qlist.h>
#include <qbytearray.h>
#include <qpointer.h>

#include "../helper/qpropertyHelper.h"

//#if ITOM_POINTCLOUDLIBRARY > 0
//Q_DECLARE_METATYPE(ito::PCLPointCloud)
//Q_DECLARE_METATYPE(QSharedPointer<ito::PCLPointCloud>)
//Q_DECLARE_METATYPE(QSharedPointer<ito::PCLPolygonMesh>)
//Q_DECLARE_METATYPE(ito::PCLPoint)
//Q_DECLARE_METATYPE(ito::PCLPolygonMesh)
//#endif
//
//Q_DECLARE_METATYPE(QSharedPointer<ito::DataObject>)
//Q_DECLARE_METATYPE(QPointer<ito::AddInDataIO>)
//Q_DECLARE_METATYPE(QPointer<ito::AddInActuator>)
//Q_DECLARE_METATYPE(ito::Shape)
//Q_DECLARE_METATYPE(QVector<ito::Shape>)


Q_DECLARE_METATYPE(ito::ItomPlotHandle)
Q_DECLARE_METATYPE(ito::PythonNone)

namespace ito
{

class PythonQtConversion
{
public:
    enum unicodeEncodings { utf_8, latin_1, iso_8859_1, mbcs, ascii, utf_16, utf_16_LE, utf_16_BE, utf_32, utf_32_BE, utf_32_LE, other };

    static PyObject* QStringToPyObject(const QString& str);

    static PyObject* QStringListToPyObject(const QStringList& list);

    static PyObject* QStringListToPyList(const QStringList& list);

    static PyObject* QDateToPyDate(const QDate& date);

    static PyObject* QDateTimeToPyDateTime(const QDateTime& datetime);

    static PyObject* QTimeToPyTime(const QTime& time);

    static QString PyObjGetRepresentation(PyObject* val);

    static QString PyObjGetString(PyObject* val) { bool ok; QString s = PyObjGetString(val, false, ok); return s; }
    static QString PyObjGetString(PyObject* val, bool strict, bool &ok);
    static std::string PyObjGetStdStringAsLatin1(PyObject* val, bool strict, bool &ok);
    static QByteArray PyObjGetBytes(PyObject* val, bool strict, bool &ok);
    static QSharedPointer<char> PyObjGetBytesShared(PyObject* val, bool strict, bool &ok);
    static int     PyObjGetInt(PyObject* val, bool strict, bool &ok);
    static qint64  PyObjGetLongLong(PyObject* val, bool strict, bool &ok);
    static quint64  PyObjGetULongLong(PyObject* val, bool strict, bool &ok);
    static double  PyObjGetDouble(PyObject* val, bool strict, bool &ok);
    static QVector<double>  PyObjGetDoubleArray(PyObject* val, bool strict, bool &ok);
    static complex128  PyObjGetComplex(PyObject* val, bool strict, bool &ok);
    static QVector<complex128>  PyObjGetComplexArray(PyObject* val, bool strict, bool &ok);
    static QVector<int>  PyObjGetIntArray(PyObject* val, bool strict, bool &ok);
    static bool    PyObjGetBool(PyObject* val, bool strict, bool &ok);
    static QVector<ito::Shape> PyObjGetShapeVector(PyObject* val, bool &ok);

#if ITOM_POINTCLOUDLIBRARY > 0
    static ito::PCLPointCloud PyObjGetPointCloud(PyObject *val, bool strict, bool &ok);
    static ito::PCLPoint PyObjGetPoint(PyObject *val, bool strict, bool &ok);
    static ito::PCLPolygonMesh PyObjGetPolygonMesh(PyObject *val, bool strict, bool &ok);

    
    static ito::PCLPointCloud* PyObjGetPointCloudNewPtr(PyObject *val, bool strict, bool &ok);
    static ito::PCLPolygonMesh* PyObjGetPolygonMeshNewPtr(PyObject *val, bool strict, bool &ok);
#endif

    static ito::DataObject* PyObjGetDataObjectNewPtr(PyObject *val, bool strict, bool &ok);

    static QSharedPointer<ito::DataObject> PyObjGetSharedDataObject(PyObject *val, bool &ok); //is always strict, only dataobjects are allowed

    static QStringList PyObjToStringList(PyObject* val, bool strict, bool& ok);


    static QVariant PyObjToQVariant(PyObject* val, int type = -1);

    static bool PyObjToVoidPtr(PyObject* val, void **retPtr, int *retType, int type = -1, bool strict = false);

    static PyObject* GetPyBool(bool val);
    static PyObject* QVariantToPyObject(const QVariant& v);

    static PyObject* QVariantMapToPyObject(const QVariantMap& m);
    static PyObject* QVariantListToPyObject(const QVariantList& l);

#if ITOM_POINTCLOUDLIBRARY > 0
    static PyObject* PCLPointCloudToPyObject(const ito::PCLPointCloud& c);
    static PyObject* PCLPointToPyObject(const ito::PCLPoint& c);
    static PyObject* PCLPolygonMeshToPyObject(const ito::PCLPolygonMesh& c);
#endif

    static PyObject* DataObjectToPyObject(const ito::DataObject& dObj);
    static PyObject* AddInBaseToPyObject(ito::AddInBase* aib);

    static PyObject* ConvertQtValueToPythonInternal(int type, const void* data); 

    static PyObject* QByteArrayToPyUnicode(const QByteArray &ba, const char *errors = "replace");
    static PyObject* QByteArrayToPyUnicodeSecure(const QByteArray &ba, const char *errors = "replace");
    static PyObject* ByteArrayToPyUnicode(const char* byteArray, Py_ssize_t len = 0, const char *errors = "replace");

    static PyObject* PyUnicodeToPyByteObject(PyObject *unicode, const char *errors = "replace");

    friend class PythonEngine; //such that the pythonEngine can set the encoding values below

private:
    static unicodeEncodings textEncoding;
    static QByteArray textEncodingName;

    static QHash<char*,PyObject*> m_pyBaseObjectStorage; 
    static void baseObjectDeleterDataObject(ito::DataObject *sharedObject)
    {
        QHash<char*,PyObject*>::iterator i = m_pyBaseObjectStorage.find((char*)sharedObject);
        if(i != m_pyBaseObjectStorage.end())
        {
            Py_XDECREF(i.value());
            m_pyBaseObjectStorage.erase(i);
        }

        delete sharedObject;
    }
};

} //end namespace ito

#endif