HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1479:704e0f1deb02

Wrapper prototype working, with all kind of Serie...

jeandet -

r1479:704e0f1deb02

parent child

Context file:

r1479:704e0f1deb02

app/PySide2-bindings/TestPlugin.py created 644 +94 0

@@ -0,0 +1,94
	1	import traceback
	2	from SciQLopBindings import PyDataProvider, Product, VectorTimeSerie, ScalarTimeSerie, DataSeriesType
	3	import numpy as np
	4	import math
	5	from spwc.cache import _cache
	6	from spwc.common.datetime_range import DateTimeRange
	7	from functools import partial
	8	from datetime import datetime, timedelta, timezone
	9	from spwc.common.variable import SpwcVariable
	10
	11
	12	def make_scalar(x):
	13	y = np.cos(x/10.)
	14	return SpwcVariable(time=x, data=y)
	15
	16	def make_vector(x):
	17	v=np.ones((len(x),3))
	18	for i in range(3):
	19	v.transpose()[:][i] = np.cos(x/10. + float(i)) + (100. * np.cos(x/10000. + float(i)))
	20	return SpwcVariable(time=x, data=v)
	21
	22
	23	def make_multicomponent(x):
	24	v=np.ones((len(x),4))
	25	for i in range(4):
	26	v.transpose()[:][i] = float(i+1) * np.cos(x/10. + float(i))
	27	return SpwcVariable(time=x, data=v)
	28
	29	def make_spectrogram(x):
	30	v=np.ones((len(x),32))
	31	for i in range(32):
	32	v.transpose()[:][i] = 100.(2.+ float(i+1) np.cos(x/1024. + float(i)))
	33	return SpwcVariable(time=x, data=v)
	34
	35
	36	def _get_data(p_type, start, stop):
	37	if type(start) is datetime:
	38	start = start.timestamp()
	39	stop = stop.timestamp()
	40	x = np.arange(math.ceil(start), math.floor(stop))*1.
	41	if p_type == 'scalar':
	42	return make_scalar(x)
	43	if p_type == 'vector':
	44	return make_vector(x)
	45	if p_type == 'multicomponent':
	46	return make_multicomponent(x)
	47	if p_type == 'spectrogram':
	48	return make_spectrogram(np.arange(math.ceil(start), math.floor(stop),15.))
	49	return None
	50
	51	class MyProvider(PyDataProvider):
	52	def __init__(self):
	53	super(MyProvider,self).__init__()
	54	self.register_products([Product("/tests/without_cache/scalar",[],{"type":"scalar"}),
	55	Product("/tests/without_cache/vector",[],{"type":"vector"}),
	56	Product("/tests/without_cache/multicomponent",[],{"type":"multicomponent",'size':'4'}),
	57	Product("/tests/without_cache/spectrogram",[],{"type":"spectrogram",'size':'32'}),
	58	Product("/tests/with_cache/scalar",[],{"type":"scalar", "cache":"true"}),
	59	Product("/tests/with_cache/vector",[],{"type":"vector", "cache":"true"}),
	60	Product("/tests/with_cache/multicomponent",[],{"type":"multicomponent",'size':'4', "cache":"true"})
	61	])
	62
	63	def get_data(self,metadata,start,stop):
	64	ts_type = DataSeriesType.SCALAR
	65	default_ctor_args = 1
	66	use_cache = False
	67	p_type = 'scalar'
	68	try:
	69	for key,value in metadata.items():
	70	if key == 'type':
	71	p_type = value
	72	if value == 'vector':
	73	ts_type = DataSeriesType.VECTOR
	74	elif value == 'multicomponent':
	75	ts_type = DataSeriesType.MULTICOMPONENT
	76	elif value == 'spectrogram':
	77	ts_type = DataSeriesType.SPECTROGRAM
	78	if key == 'cache' and value == 'true':
	79	use_cache = True
	80	if use_cache:
	81	cache_product = f"tests/{p_type}"
	82	var = _cache.get_data(cache_product, DateTimeRange(datetime.fromtimestamp(start, tz=timezone.utc), datetime.fromtimestamp(stop, tz=timezone.utc)), partial(_get_data, p_type), fragment_hours=24)
	83	else:
	84	print("No Cache")
	85	var = _get_data(p_type, start, stop)
	86	return ((var.time,var.data), ts_type)
	87	except Exception as e:
	88	print(traceback.format_exc())
	89	print("Error in test.py ",str(e))
	90	return ((np.array(), np.array()), ts_type)
	91
	92
	93	t=MyProvider()
	94

app/PySide2-bindings/CMakeLists.txt +1 0

             find_package(PythonLibs 3 REQUIRED)
             find_package(PythonInterp 3 REQUIRED)
             find_package(PySide2  REQUIRED)
             find_package(Shiboken2  REQUIRED)
             include(PythonInfo)
             find_python_site_packages(PYTHON_SITE_PACKAGES)
             set(BINDINGS_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
             set(BINDINGS_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}")
             configure_file("${BINDINGS_SRC_DIR}/bindings.xml" "${BINDINGS_BUILD_DIR}/bindings.xml" COPYONLY)
             configure_file("${BINDINGS_SRC_DIR}/main.py" "${BINDINGS_BUILD_DIR}/main.py" COPYONLY)
+            configure_file("${BINDINGS_SRC_DIR}/TestPlugin.py" "${BINDINGS_BUILD_DIR}/plugins/TestPlugin.py" COPYONLY)
             execute_process(COMMAND "${PYTHON_EXECUTABLE}" "${BINDINGS_SRC_DIR}/src_list.py" cmake "${BINDINGS_BUILD_DIR}" OUTPUT_VARIABLE BINDINGS_SOURCE)
             set_property(SOURCE ${BINDINGS_SOURCE} PROPERTY SKIP_AUTOGEN ON)
             list(APPEND BINDINGS_INCLUDE_DIRS
                 ${PYTHON_INCLUDE_DIRS}
                 ${Qt5Core_INCLUDE_DIRS}
                 ${Qt5Widgets_INCLUDE_DIRS}
                 ${Qt5Gui_INCLUDE_DIRS}
                 ${CMAKE_CURRENT_SOURCE_DIR}/../../gui/include
                 ${CMAKE_CURRENT_SOURCE_DIR}/../../core/include
                 ${CMAKE_CURRENT_SOURCE_DIR}/../../core/external/TimeSeries/include
                 )
             list(REMOVE_DUPLICATES BINDINGS_INCLUDE_DIRS)
             foreach(DIR ${BINDINGS_INCLUDE_DIRS})
                 list(APPEND BINDINGS_INCLUDE_DIRS_ARGS "-I${DIR}")
             endforeach()
             set(SHIBOKEN_OPTIONS --generator-set=shiboken
                 --enable-parent-ctor-heuristic
                 --enable-return-value-heuristic
                 --use-isnull-as-nb_nonzero
                 --avoid-protected-hack
                 --enable-pyside-extensions
                 -std=c++17)
             add_custom_command(
                     OUTPUT ${BINDINGS_SOURCE}
                     COMMAND Shiboken2::shiboken2 ${SHIBOKEN_OPTIONS}
                          ${BINDINGS_INCLUDE_DIRS_ARGS}
                         --typesystem-paths=${PYSIDE_TYPESYSTEMS}
                         --output-directory=${CMAKE_CURRENT_BINARY_DIR}
                         ${CMAKE_CURRENT_SOURCE_DIR}/bindings.h ${CMAKE_CURRENT_SOURCE_DIR}/bindings.xml
                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/bindings.xml"
                     IMPLICIT_DEPENDS CXX "${CMAKE_CURRENT_SOURCE_DIR}/bindings.h"
                     WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
                     COMMENT "Generating Python bindings with shiboken2")
             include_directories(
                 ${PYSIDE_INCLUDE_DIR}/QtCore
                 ${PYSIDE_INCLUDE_DIR}/QtGui
                 ${PYSIDE_INCLUDE_DIR}/QtWidgets)
             include_directories(
                         ${PYTHON_SITE_PACKAGES}/numpy/core/include/
                         ${PYTHON_INCLUDE_DIRS}
                         ${SHIBOKEN_INCLUDE_DIR}
                         ${PYSIDE_INCLUDE_DIR}
                         ${PYSIDE_INCLUDE_DIR}/QtCore
                         ${PYSIDE_INCLUDE_DIR}/QtGui
                         ${PYSIDE_INCLUDE_DIR}/QtWidgets)
             add_library(SciQLopBindings MODULE ${BINDINGS_SOURCE} numpy_wrappers.h PyDataProvider.h)
             set_target_properties(
                 SciQLopBindings
                 PROPERTIES
                     PREFIX ""
                     OUTPUT_NAME "SciQLopBindings"
                 )
             target_link_libraries(SciQLopBindings sciqlopapp)
             target_link_libraries(SciQLopBindings Shiboken2::libshiboken)
             target_link_libraries(SciQLopBindings PySide2::pyside2)
             add_executable(debug_sciqlop_app main.cpp )
             find_package (Python3 COMPONENTS Development)
             target_link_libraries(debug_sciqlop_app PRIVATE Python3::Python)

app/PySide2-bindings/PyDataProvider.h +49 -27

             #pragma once
             #include <Data/DataProviderParameters.h>
+            #include <Data/DataSeriesType.h>
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <QPair>
             #include <SqpApplication.h>
             // must be included last because of Python/Qt definition of slots
             #include "numpy_wrappers.h"
             struct Product
             {
                 QString path;
                 std::vector<std::string> components;
                 QMap<QString, QString> metadata;
                 Product() = default;
                 explicit Product(const QString& path, const std::vector<std::string>& components,
                     const QMap<QString, QString>& metadata)
                         : path { path }, components { components }, metadata { metadata }
                 {
                 }
-                virtual ~Product() = default;
+                ~Product() = default;
             };
             class PyDataProvider : public IDataProvider
             {
             public:
                 PyDataProvider()
                 {
                     auto& dataSourceController = sqpApp->dataSourceController();
                     dataSourceController.registerProvider(this);
                 }
                 virtual ~PyDataProvider() {}
-                virtual QPair<NpArray, NpArray> getData(
+                virtual QPair<QPair<NpArray,NpArray>,DataSeriesType> get_data(const QMap<QString,QString>& key, double start_time, double stop_time)
-                    const std::string& key, double start_time, double stop_time)
                 {
                     (void)key, (void)start_time, (void)stop_time;
                     return {};
                 }
                 virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters) override
                 {
                     if (parameters.m_Data.contains("name"))
                     {
-                        auto data = getData(parameters.m_Data["name"].toString().toStdString(),
+                        QMap<QString,QString> metadata;
+                        std::for_each(parameters.m_Data.constKeyValueBegin(), parameters.m_Data.constKeyValueEnd(), [&metadata](const auto& item) {
+                            metadata[item.first] = item.second.toString();
+                            });
+                        auto [data, type] = get_data(metadata,
                             parameters.m_Range.m_TStart, parameters.m_Range.m_TEnd);
                         // TODO add shape/type switch
-                        return new ScalarTimeSerie { data.first.to_std_vect(), data.second.to_std_vect() };
+                        //if (builder)
+                        {
+                            auto& [t,y]=data;
+                            switch (type)
+                            {
+                                case DataSeriesType::SCALAR:
+                                    return new ScalarTimeSerie { std::move(t.data),
+                                        std::move(y.data) };
+                                    break;
+                                case DataSeriesType::VECTOR:
+                                    return new VectorTimeSerie { std::move(t.data),
+                                        y.to_std_vect_vect() };
+                                    break;
+                                case DataSeriesType::MULTICOMPONENT:
+                                {
+                                    auto y_size = y.flat_size();
+                                    auto t_size = t.flat_size();
+                                    if(t_size && (y_size%t_size)==0)
+                                    {
+                                        return new MultiComponentTimeSerie { std::move(t.data),
+                                            std::move(y.data),{t_size, y_size/t_size} };
+                                    }
+                                    break;
+                                }
+                                case DataSeriesType::SPECTROGRAM:
+                                {
+                                    auto y_size = y.flat_size();
+                                    auto t_size = t.flat_size();
+                                    if(t_size && (y_size%t_size)==0)
+                                    {
+                                        return new SpectrogramTimeSerie { std::move(t.data),
+                                            std::move(y.data),{t_size, y_size/t_size} };
+                                    }
+                                    break;
+                                }
+                                default:
+                                    break;
+                            }
+                        }
                     }
                     return nullptr;
                 }
                 inline void register_products(const QVector<Product*>& products)
                 {
                     auto& dataSourceController = sqpApp->dataSourceController();
                     auto id = this->id();
                     auto data_source_name = this->name();
                     std::for_each(std::cbegin(products), std::cend(products),
                         [&id, &dataSourceController](const Product* product) {
                             dataSourceController.setDataSourceItem(id, product->path, product->metadata);
                         });
                 }
             };
-            struct Providers
-                Providers() = default;
-                virtual ~Providers() = default;
-                inline void register_provider(PyDataProvider* provider)
-                    auto& dataSourceController = sqpApp->dataSourceController();
-                    dataSourceController.setDataProvider(
-                        provider->id(), std::unique_ptr<IDataProvider>(provider));
-            };
-            inline ScalarTimeSerie test_PyDataProvider(PyDataProvider& prov)
-                auto v = prov.getData("", 0., 0.);
-                ScalarTimeSerie s;
-                s.set_data(v.first.to_std_vect(), v.second.to_std_vect());
-                return s;

app/PySide2-bindings/bindings.h +2 0

             #ifndef SCIQLOP_BINDINGS_H
             #define SCIQLOP_BINDINGS_H
             #define QT_ANNOTATE_ACCESS_SPECIFIER(a) __attribute__((annotate(#a)))
             #include "../include/MainWindow.h"
             #include "PyDataProvider.h"
             #include "numpy_wrappers.h"
             #include <Data/IDataProvider.h>
             #include <Data/ScalarTimeSerie.h>
+            #include <Data/VectorTimeSerie.h>
+            #include <Data/DataSeriesType.h>
             #include <SqpApplication.h>
             #endif // SCIQLOP_BINDINGS_H

app/PySide2-bindings/bindings.xml +36 -24

             <?xml version="1.0"?>
             <typesystem package="SciQLopBindings">
                 <load-typesystem name="typesystem_core.xml" generate="no" />
                 <load-typesystem name="typesystem_gui.xml" generate="no" />
                 <load-typesystem name="typesystem_widgets.xml" generate="no" />
                 <primitive-type name="std::string"/>
                 <primitive-type name="std::size_t"/>
+                <enum-type name="DataSeriesType"/>
                 <container-type name="std::vector" type="vector">
                     <include file-name="vector" location="global"/>
                     <conversion-rule>
                         <native-to-target>
                             %INTYPE::size_type vectorSize = %in.size();
                             PyObject* %out = PyList_New((int) vectorSize);
                             for (%INTYPE::size_type idx = 0; idx &lt; vectorSize; ++idx) {
                                 %INTYPE_0 cppItem(%in[idx]);
                                 PyList_SET_ITEM(%out, idx, %CONVERTTOPYTHON[%INTYPE_0](cppItem));
                             }
                             return %out;
                         </native-to-target>
                         <target-to-native>
                             <add-conversion type="PySequence">
                                 Shiboken::AutoDecRef seq(PySequence_Fast(%in, 0));
                                 int vectorSize = PySequence_Fast_GET_SIZE(seq.object());
                                 %out.reserve(vectorSize);
                                 for (int idx = 0; idx &lt; vectorSize; ++idx ) {
                                     PyObject* pyItem = PySequence_Fast_GET_ITEM(seq.object(), idx);
                                     %OUTTYPE_0 cppItem = %CONVERTTOCPP[%OUTTYPE_0](pyItem);
                                     %out.push_back(cppItem);
                                 }
                             </add-conversion>
                         </target-to-native>
                     </conversion-rule>
                 </container-type>
-                <object-type name="PyDataProvider" />
+                <primitive-type name="NpArray" target-lang-api-name="PyObject">
+                  <include file-name="numpy_wrappers.h" location="local"/>
+                  <conversion-rule>
+                      <native-to-target>
+                      auto result = %in.py_object();
+                      return result;
+                      </native-to-target>
+                      <target-to-native>
+                        <add-conversion type="PyObject" check="NpArray::isNpArray(%in)">
+                        %out = %OUTTYPE(%in);
+                        </add-conversion>
+                      </target-to-native>
+                    </conversion-rule>
+                </primitive-type>
+                <object-type name="PyDataProvider"/>
                 <object-type name="Product" />
                 <object-type name="MainWindow" />
                 <object-type name="SqpApplication">
                     <modify-function signature="SqpApplication(int&amp;,char**)" access="private"/>
                 </object-type>
-                <object-type name="Providers">
-                    <modify-function  signature="register_provider(PyDataProvider*)">
-                      <modify-argument index="1">
-                          <define-ownership owner="c++" />
-                      </modify-argument>
-                    </modify-function>
-                </object-type>
                 <function signature="SqpApplication_ctor()" return-type="SqpApplication*"/>
                 <add-function signature="SqpApplication_ctor(PySequence)" return-type="SqpApplication*">
                     <inject-code class="target">
                         static int argc;
                         static char **argv;
                         Shiboken::listToArgcArgv(%1, &amp;argc, &amp;argv, "PySideApp");
                         auto retval = new SqpApplication(argc,argv);
                         %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval);
                     </inject-code>
                 </add-function>
                 <function signature="init_resources()"/>
-                <primitive-type name="NpArray" target-lang-api-name="PyObject">
-                  <include file-name="numpy_wrappers.h" location="local"/>
-                  <conversion-rule>
-                      <native-to-target>
-                      auto result = %in.py_object();
-                      return result;
-                      </native-to-target>
-                      <target-to-native>
-                        <add-conversion type="PyObject" check="NpArray::isNpArray(%in)">
-                        %out = %OUTTYPE(%in);
-                        </add-conversion>
-                      </target-to-native>
-                    </conversion-rule>
-                </primitive-type>
                 <function signature="load_plugins(const SqpApplication&amp;)"/>
                 <object-type name="ScalarTimeSerie">
                     <add-function signature="ScalarTimeSerie(NpArray&amp;,NpArray&amp;)" return-type="ScalarTimeSerie">
                         <inject-code class="target">
                             %BEGIN_ALLOW_THREADS
                             %0 = new ScalarTimeSerieWrapper();
-                            %0.set_data(%1.to_std_vect(),%2.to_std_vect());
+                            %0.set_data(std::move(%1.data),std::move(%2.data));
+                            %END_ALLOW_THREADS
+                        </inject-code>
+                    </add-function>
+                    <add-function signature="size()" return-type="int" access="public" static="no">
+                        <inject-code class="target">
+                            %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME();
+                            %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
+                        </inject-code>
+                    </add-function>
+                </object-type>
+                <object-type name="VectorTimeSerie">
+                    <add-function signature="VectorTimeSerie(NpArray&amp;,NpArray&amp;)" return-type="VectorTimeSerie">
+                        <inject-code class="target">
+                            %BEGIN_ALLOW_THREADS
+                            %0 = new VectorTimeSerieWrapper();
+                            %0.set_data(std::move(%1.data),%2.to_std_vect_vect());
                             %END_ALLOW_THREADS
                         </inject-code>
                     </add-function>
                     <add-function signature="size()" return-type="int" access="public" static="no">
                         <inject-code class="target">
                             %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME();
                             %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
                         </inject-code>
                     </add-function>
                 </object-type>
-                <function signature="test_PyDataProvider(PyDataProvider&amp;)"/>
                 <function signature="test_np_array(NpArray&amp;)"/>
             </typesystem>

app/PySide2-bindings/main.py +3 0

             # This Python file uses the following encoding: utf-8
             import os
             print(os.getcwd())
             import sys
             from PySide2.QtWidgets import QApplication, QMainWindow, QDockWidget
             from PySide2.QtCore import QSize, Qt
             from PySide2 import QtGui
             import os
             sys.path.append(os.getcwd())
             from SciQLopBindings import SqpApplication, MainWindow, init_resources, load_plugins, SqpApplication_ctor
             from qtconsole.rich_ipython_widget import RichJupyterWidget
             from qtconsole.inprocess import QtInProcessKernelManager
             class IPythonWidget(RichJupyterWidget):
                 """Live IPython console widget.
                 .. image:: img/IPythonWidget.png
                 :param custom_banner: Custom welcome message to be printed at the top of
                    the console.
                 """
                 def __init__(self, parent=None, custom_banner=None, *args, **kwargs):
                     if parent is not None:
                         kwargs["parent"] = parent
                     super(IPythonWidget, self).__init__(*args, **kwargs)
                     if custom_banner is not None:
                         self.banner = custom_banner
                     self.setWindowTitle(self.banner)
                     self.kernel_manager = kernel_manager = QtInProcessKernelManager()
                     kernel_manager.start_kernel()
                     self.kernel_client = kernel_client = self._kernel_manager.client()
                     kernel_client.start_channels()
                     def stop():
                         kernel_client.stop_channels()
                         kernel_manager.shutdown_kernel()
                     self.exit_requested.connect(stop)
                 def sizeHint(self):
                     """Return a reasonable default size for usage in :class:`PlotWindow`"""
                     return QSize(500, 300)
                 def pushVariables(self, variable_dict):
                     """ Given a dictionary containing name / value pairs, push those
                     variables to the IPython console widget.
                     :param variable_dict: Dictionary of variables to be pushed to the
                         console's interactive namespace (```{variable_name: object, …}```)
                     """
                     self.kernel_manager.kernel.shell.push(variable_dict)
             class IPythonDockWidget(QDockWidget):
                 """Dock Widget including a :class:`IPythonWidget` inside
                 a vertical layout.
                 .. image:: img/IPythonDockWidget.png
                 :param available_vars: Dictionary of variables to be pushed to the
                     console's interactive namespace: ``{"variable_name": object, …}``
                 :param custom_banner: Custom welcome message to be printed at the top of
                     the console
                 :param title: Dock widget title
                 :param parent: Parent :class:`qt.QMainWindow` containing this
                     :class:`qt.QDockWidget`
                 """
                 def __init__(self, parent=None, available_vars=None, custom_banner=None,
                              title="Console"):
                     super(IPythonDockWidget, self).__init__(title, parent)
                     self.ipyconsole = IPythonWidget(custom_banner=custom_banner)
                     self.layout().setContentsMargins(0, 0, 0, 0)
                     self.setWidget(self.ipyconsole)
                     if available_vars is not None:
                         self.ipyconsole.pushVariables(available_vars)
                     self.ipyconsole.pushVariables({"blah":self})
                 def showEvent(self, event):
                     """Make sure this widget is raised when it is shown
                     (when it is first created as a tab in PlotWindow or when it is shown
                     again after hiding).
                     """
                     self.raise_()
             def print_process_id():
                 print ('Process ID is:', os.getpid())
             if __name__ == "__main__":
                 init_resources()
                 app = SqpApplication_ctor(sys.argv)
                 QtGui.qApp = app
                 load_plugins(app)
                 main_window = MainWindow()
                 term = IPythonDockWidget(available_vars={"app":app, "main_window":main_window}, custom_banner="SciQLop IPython Console ")
                 main_window.addDockWidget(Qt.BottomDockWidgetArea, term)
                 main_window.show()
+                for file in os.listdir('plugins'):
+                    if os.path.isfile(f"plugins/{file}"):
+                        exec(open(f"plugins/{file}").read())
                 sys.exit(app.exec_())

app/PySide2-bindings/numpy_wrappers.h +102 -20

             #ifndef NUMPY_WRAPPERS_H
             #define NUMPY_WRAPPERS_H
             #include <Data/ScalarTimeSerie.h>
+            #include <Data/VectorTimeSerie.h>
             #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
             #if defined(slots) && (defined(__GNUC__) || defined(_MSC_VER) || defined(__clang__))
             #pragma push_macro("slots")
             #undef slots
             extern "C"
             {
             /*
              * Python 2 uses the "register" keyword, which is deprecated in C++ 11
              * and forbidden in C++17.
              */
             #if defined(__clang__)
             #pragma clang diagnostic push
             #pragma clang diagnostic ignored "-Wdeprecated-register"
             #endif
             #include <Python.h>
             #include <numpy/arrayobject.h>
             #if defined(__clang__)
             #pragma clang diagnostic pop
             #endif
             }
             #else
             #include <Python.h>
             #include <numpy/arrayobject.h>
             #endif
             #include <assert.h>
             #include <map>
             inline int init_numpy()
             {
                 import_array(); // PyError if not successful
                 return 0;
             }
             const static int numpy_initialized = init_numpy();
             template <typename dest_type = PyObject>
             struct PyObjectWrapper
             {
             private:
                 PyObject* _py_obj = nullptr;
-                void inc_refcount()
+                void inc_refcount() { Py_XINCREF(_py_obj); }
-                    Py_XINCREF(_py_obj);
                 void dec_refcount()
                 {
                     Py_XDECREF(_py_obj);
                     _py_obj = nullptr;
                 }
             public:
                 PyObjectWrapper() : _py_obj { nullptr } {}
                 PyObjectWrapper(const PyObjectWrapper& other) : _py_obj { other._py_obj } { inc_refcount(); }
                 PyObjectWrapper(PyObjectWrapper&& other) : _py_obj { other._py_obj } { inc_refcount(); }
-                explicit PyObjectWrapper(PyObject* obj) : _py_obj { obj }
+                explicit PyObjectWrapper(PyObject* obj) : _py_obj { obj } { inc_refcount(); }
-                    inc_refcount();
                 ~PyObjectWrapper() { dec_refcount(); }
                 PyObjectWrapper& operator=(PyObjectWrapper&& other)
                 {
                     dec_refcount();
                     this->_py_obj = other._py_obj;
                     inc_refcount();
                     return *this;
                 }
                 PyObjectWrapper& operator=(const PyObjectWrapper& other)
                 {
                     dec_refcount();
                     this->_py_obj = other._py_obj;
                     inc_refcount();
                     return *this;
                 }
                 PyObject* py_object() { return _py_obj; }
                 inline dest_type* get() { return reinterpret_cast<dest_type*>(_py_obj); }
                 inline bool is_null() { return _py_obj == nullptr; }
             };
-            struct NpArray
+            struct NpArray_view
             {
             private:
                 PyObjectWrapper<PyArrayObject> _py_obj;
-                NpArray(NpArray& other) = delete;
+                NpArray_view(const NpArray_view&& other) = delete;
-                NpArray(const NpArray& other) = delete;
-                NpArray(const NpArray&& other) = delete;
             public:
                 static bool isNpArray(PyObject* obj)
                 {
                     auto arr = reinterpret_cast<PyArrayObject*>(obj);
                     auto is_c_aray = obj && PyArray_Check(arr) && PyArray_ISCARRAY(arr);
                     return is_c_aray;
                 }
-                NpArray() : _py_obj { nullptr } {}
+                NpArray_view() : _py_obj { nullptr } {}
-                NpArray(NpArray&& other) : _py_obj { other._py_obj } {}
+                NpArray_view(const NpArray_view& other) : _py_obj { other._py_obj } {}
-                explicit NpArray(PyObject* obj) : _py_obj { obj }
+                NpArray_view(NpArray_view&& other) : _py_obj { other._py_obj } {}
+                explicit NpArray_view(PyObject* obj) : _py_obj { obj }
                 {
                     assert(isNpArray(obj));
                     assert(PyArray_ISFLOAT(_py_obj.get()));
                 }
-                NpArray& operator=(const NpArray& other)
+                NpArray_view& operator=(const NpArray_view& other)
                 {
                     this->_py_obj = other._py_obj;
                     return *this;
                 }
-                NpArray& operator=(NpArray&& other)
+                NpArray_view& operator=(NpArray_view&& other)
                 {
                     this->_py_obj = other._py_obj;
                     return *this;
                 }
                 std::vector<std::size_t> shape()
                 {
                     std::vector<std::size_t> shape;
                     if (!_py_obj.is_null())
                     {
                         if (int ndim = PyArray_NDIM(_py_obj.get()); ndim > 0)
                         {
                             if (ndim < 10)
                             {
                                 shape.resize(ndim);
                                 std::copy_n(PyArray_SHAPE(_py_obj.get()), ndim, std::begin(shape));
                             }
                         }
                     }
                     return shape;
                 }
+                std::size_t ndim()
+                {
+                    if (!_py_obj.is_null())
+                    {
+                        return static_cast<std::size_t>(PyArray_NDIM(_py_obj.get()));
+                    }
+                    return 0;
+                }
+                std::size_t size(std::size_t index = 0)
+                {
+                    if (!_py_obj.is_null())
+                    {
+                        if (index < static_cast<std::size_t>(PyArray_NDIM(_py_obj.get())))
+                        {
+                            return PyArray_SHAPE(_py_obj.get())[index];
+                        }
+                    }
+                    return 0;
+                }
                 std::size_t flat_size()
                 {
                     auto s = this->shape();
-                    return std::accumulate(std::cbegin(s), std::cend(s), 0);
+                    return std::accumulate(
+                        std::cbegin(s), std::cend(s), 1, [](const auto& a, const auto& b) { return a * b; });
                 }
                 double data(std::size_t pos)
                 {
                     if (!_py_obj.is_null())
                     {
                         return reinterpret_cast<double*>(PyArray_DATA(_py_obj.get()))[pos];
                     }
                     return nan("NAN");
                 }
                 std::vector<double> to_std_vect()
                 {
+                    assert(!this->_py_obj.is_null());
                     auto sz = flat_size();
                     std::vector<double> v(sz);
                     auto d_ptr = reinterpret_cast<double*>(PyArray_DATA(_py_obj.get()));
                     std::copy(d_ptr, d_ptr + sz, std::begin(v));
                     return v;
                 }
+                std::vector<VectorTimeSerie::raw_value_type> to_std_vect_vect()
+                {
+                    auto sz = size(0);
+                    std::vector<VectorTimeSerie::raw_value_type> v(sz);
+                    if (sz)
+                    {
+                        assert(ndim() == 2);
+                        assert(size(1) == 3);
+                        auto d_ptr
+                            = reinterpret_cast<VectorTimeSerie::raw_value_type*>(PyArray_DATA(_py_obj.get()));
+                        std::copy(d_ptr, d_ptr + sz, std::begin(v));
+                    }
+                    return v;
+                }
                 PyObject* py_object() { return _py_obj.py_object(); }
             };
+            struct NpArray
+            {
+                std::vector<std::size_t> shape;
+                std::vector<double> data;
+                static bool isNpArray(PyObject* obj) { return NpArray_view::isNpArray(obj); }
+                NpArray() = default;
+                explicit NpArray(PyObject* obj)
+                {
+                    if (obj)
+                    {
+                        NpArray_view view { obj };
+                        shape = view.shape();
+                        data = view.to_std_vect();
+                    }
+                }
+                inline std::size_t ndim() { return shape.size(); }
+                std::size_t size(std::size_t index = 0)
+                {
+                    if (index < shape.size())
+                        return shape[index];
+                    return 0;
+                }
+                std::size_t flat_size()
+                {
+                    return std::accumulate(std::cbegin(shape), std::cend(shape), 1,
+                        [](const auto& a, const auto& b) { return a * b; });
+                }
+                // TODO temporary hack should find a way to avoid this copy
+                std::vector<VectorTimeSerie::raw_value_type> to_std_vect_vect()
+                {
+                    auto sz = size(0);
+                    std::vector<VectorTimeSerie::raw_value_type> v(sz);
+                    if (sz)
+                    {
+                        assert(ndim() == 2);
+                        assert(size(1) == 3);
+                        auto d_ptr = reinterpret_cast<VectorTimeSerie::raw_value_type*>(data.data());
+                        std::copy(d_ptr, d_ptr + sz, std::begin(v));
+                    }
+                    return v;
+                }
+                // TODO maybe ;)
+                PyObject* py_object() { return nullptr; }
+            };
             inline int test_np_array(NpArray& arr)
             {
-                auto shape = arr.shape();
+                auto shape = arr.shape;
                 std::cout << "len(shape)=" << shape.size() << std::endl;
                 std::for_each(std::cbegin(shape), std::cend(shape), [](auto sz) {
                     static int i = 0;
                     std::cout << "shape[" << i++ << "]=" << sz << std::endl;
                 });
                 auto flatsize = std::accumulate(std::cbegin(shape), std::cend(shape), 0);
                 for (auto i = 0; i < flatsize; i++)
                 {
-                    std::cout << "data[" << i << "]=" << arr.data(i) << std::endl;
+                    std::cout << "data[" << i << "]=" << arr.data[i] << std::endl;
                 }
                 return 1;
             }
             #endif //#ifndef NUMPY_WRAPPERS_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages