SegmentSignalPy 0.1.3__cp315-cp315-win_amd64.whl

CPP Static Library/SegmentSignalFunctions.h

@@ -0,0 +1,52 @@
+#ifndef SEGMENTSIGNALFUNCTIONS_H
+#define SEGMENTSIGNALFUNCTIONS_H
+/*
+	C function calls for the signal segmentation libary.
+	These functions are where the work is performed.
+*/
+
+// MAIN FUNCTION
+//                 In                                                                               Out
+void SegmentSignal(double LOG[], int NSAMPS, double F, int ORDER, int ORDER1, int RMODE, int NITER, int Q[], int& NQ, double FLTLOG[], double SEGLOG[], double R[], double& C, double& D, int& NACT, int& IER);
+
+// HELPER FUNCTIONS
+//                                   In                                                               Out
+void SingleMostLikelihoodReplacement(double G[], double S[], double C, int NSAMPS, double D, int Q[], bool& CONV, int& IER);
+
+//             In                                               Out
+void Threshold(double JMPSEQ[], double C, double F, int NSAMPS, int Q[], double& D);
+
+//                 In                                    Out
+void MovingAverage(double ARR1[], int NSAMPS, int ORDER, double ARR2[]);
+
+//                In                                                       Out
+void KalmanFilter(double LOG[], int Q[], double C, double R[], int NSAMPS, double GAIN[], double ZTLT[], double ETA[], double STATE[]);
+
+//                                In                             In/Out
+void FixedIntervalOptimalSmoother(int Q[], int NSAMPS, double C, double ARR1[], double ARR2[], double ARR3[]);
+
+//                        In                                 Out
+void AverageArraySegments(double ARR[], int Q[], int NSAMPS, double AVGOUT[]);
+
+//                                    In                                            Intermediate    Out
+void DeglitchAndEstimateNoiseVariance(double LOG[], int Q[], int NSAMPS, int RMODE, double WORK1[], double R[]);
+
+//              In                                             Out
+void GetSegment(double LOG[], int Q[], int NSAMPS, int SEGSTR, int& SEGEND, int& SEGLEN, double& SEGAVG, bool& endofarray);
+
+//            In          In/Out
+void Deglitch(int NSAMPS, int Q[]);
+
+//                 In                               Out
+void GetSpikeyZone(int Q[], int NSAMPS, int SEGSTR, int& SEGEND, bool& endofarray);
+
+//                        In                   Out
+void EstimateEventDensity(int Q[], int NSAMPS, double& D, int& NQ);
+
+//                                  In                        Intermediate    Out
+void EstimateVarianceOfJumpSequence(double LOG[], int NSAMPS, double WORK1[], double& C);
+
+//                            In                                    Out
+void CalculateMeanAndVariance(double ARRAY[], int NSAMPS, int MODE, double& MEAN, double& VAR);
+
+#endif

CPP Static Library/SegmentationResults.cpp

@@ -0,0 +1,82 @@
+#include "SegmentationResults.h"
+
+namespace Algorithms
+{
+	SegmentationResults::SegmentationResults(int signalLength, int binaryEventSequence[], int numberOfBinaryEvents, double filteredSignal[], double segmentedLog[], double noiseVariance[], double jumpSequenceVariance, double segmentDensity, int iterations, int error)
+	{
+		_signalLength			= signalLength;
+
+		_binaryEventSequence	= binaryEventSequence;
+		_numberOfBinaryEvents	= numberOfBinaryEvents;
+		_filteredSignal			= filteredSignal;
+		_segmentedLog			= segmentedLog;
+		_noiseVariance			= noiseVariance;
+
+		_jumpSequenceVariance	= jumpSequenceVariance;
+		_segmentDensity			= segmentDensity;
+		_iterations				= iterations;
+		_error					= error;
+	}
+
+	SegmentationResults::~SegmentationResults()
+	{
+		if (_binaryEventSequence)
+		{
+			delete _binaryEventSequence;
+			delete _filteredSignal;
+			delete _segmentedLog;
+			delete _noiseVariance;
+		}
+	}
+
+	int SegmentationResults::GetSignalLength()
+	{
+		return _signalLength;
+	}
+
+	int* SegmentationResults::GetBinaryEventSequence()
+	{
+		return _binaryEventSequence;
+	}
+
+	int SegmentationResults::GetNumberOfBinaryEvents()
+	{
+		return _numberOfBinaryEvents;
+	}
+
+	double* SegmentationResults::GetFilteredSignal()
+	{
+		return _filteredSignal;
+	}
+
+	double* SegmentationResults::GetSegmentedLog()
+	{
+		return _segmentedLog;
+	}
+
+	double* SegmentationResults::GetNoiseVariance()
+	{
+		return _noiseVariance;
+	}
+
+	double SegmentationResults::GetJumpSequenceVariance()
+	{
+		return _jumpSequenceVariance;
+	}
+
+	double SegmentationResults::GetSegmentDensity()
+	{
+		return _segmentDensity;
+	}
+		
+	int SegmentationResults::GetIterations()
+	{
+		return _iterations;
+	}
+
+	int SegmentationResults::GetError()
+	{
+		return _error;
+	}
+
+} // End namespace.

CPP Static Library/SegmentationResults.h

@@ -0,0 +1,101 @@
+#ifndef SEGMENTATIONRESULTS_H
+#define SEGMENTATIONRESULTS_H
+
+namespace Algorithms
+{
+	class SegmentationResults
+	{
+		private:
+			int			_signalLength;
+			int*		_binaryEventSequence			= 0;
+			int			_numberOfBinaryEvents;
+			double*		_filteredSignal					= 0;
+			double*		_segmentedLog					= 0;
+			double*		_noiseVariance					= 0;
+			double		_jumpSequenceVariance;
+			double		_segmentDensity;
+			int			_iterations;
+			int			_error;
+
+		public:
+			/// <summary>
+			/// Constructor.
+			/// </summary>
+			/// <param name="signalLength">Length of the input signal.  The output sequences are the name length.</param>
+			/// <param name="binaryEventSequence">Binary event sequence.</param>
+			/// <param name="numberOfBinaryEvents">Number of binary events found (number of "1"s found in binary event sequence).</param>
+			/// <param name="filteredSignal">Filtered signal.</param>
+			/// <param name="segmentedLog">Segmented log.</param>
+			/// <param name="noiseVariance">Noise variance.</param>
+			/// <param name="jumpSequenceVariance">Jump sequence variance.</param>
+			/// <param name="segmentDensity">Segment density (ratio of events to total entries in binary event sequence).</param>
+			/// <param name="iterations">Number of iterations performed.</param>
+			/// <param name="error">Error flag.</param>
+			SegmentationResults(int signalLength, int binaryEventSequence[], int numberOfBinaryEvents, double filteredSignal[], double segmentedLog[], double noiseVariance[], double jumpSequenceVariance, double segmentDensity, int iterations, int error);
+
+			/// <summary>
+			/// destructor.
+			/// </summary>
+			~SegmentationResults();
+
+		public:
+			/// <summary>
+			/// Length of the input signal.  The output sequences are the name length.
+			/// </summary>
+			int GetSignalLength();
+
+			/// <summary>
+			/// Array that contains 1s at segmented log boundaries and 0s elsewhere.
+			/// </summary>
+			int* GetBinaryEventSequence();
+
+			/// <summary>
+			/// Number of binary event sequences detected (number of "1"s in the BinaryEventSequence array).
+			/// </summary>
+			int GetNumberOfBinaryEvents();
+
+			/// <summary>
+			/// Filtered estimate of the signal.
+			/// </summary>
+			double* GetFilteredSignal();
+
+			/// <summary>
+			/// Average of filter log for each segment.
+			/// </summary>
+			double* GetSegmentedLog();
+
+			/// <summary>
+			/// Estimate noise variance.
+			/// </summary>
+			double* GetNoiseVariance();
+
+			/// <summary>
+			/// Estimated variance of the jump sequence.
+			/// </summary>
+			double GetJumpSequenceVariance();
+
+			/// <summary>
+			/// Estimate segment density.
+			/// </summary>
+			double GetSegmentDensity();
+		
+			/// <summary>
+			/// SMLR iteration count.
+			/// </summary>
+			int GetIterations();
+
+			/// <summary>
+			/// Error flag.
+			///		Zero - no error.
+			///		Less than zero - invalid event density estimated after threshold.  Reduce/increase
+			///			threshold and rerun.
+			///		Greater than zero - logarithm argument became zero at sample number returned in error during
+			///			the calculation of likelihood ratios in SMLR.  There may be more samples of this type which
+			///			may give rise to this problem.  Edit/rescale data values and rerun.
+			/// </summary>
+			int GetError();
+
+	}; // End class.
+} // End namespace.
+
+#endif

CPP Unit Tests/InputDataEnum.h

@@ -0,0 +1,14 @@
+#ifndef INPUTDATAENUM_H
+#define INPUTDATAENUM_H
+
+// Enumeration stating how data is located in the data file.
+enum class InputData
+{
+	Depth = 0,
+	Log,
+	SegmentedLog,
+	EventSequence,
+	FilteredLog
+};
+
+#endif

CPP Unit Tests/stdafx.h

@@ -0,0 +1,13 @@
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+#include "targetver.h"
+
+// Headers for CppUnitTest
+#include "CppUnitTest.h"
+
+// TODO: reference additional headers your program requires here

CPP Unit Tests/targetver.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>

Python Extension/SegmentationResultsPy.cpp

@@ -0,0 +1,126 @@
+#include "SegmentationResultsPy.h"
+
+namespace PythonAlgorithms
+{
+	SegmentationResults::SegmentationResults()
+	{
+		_numberOfBinaryEvents		= 0;
+		_jumpSequenceVariance		= 0;
+		_segmentDensity				= 0;
+		_iterations					= 0;
+		_error						= 0;
+
+		_binaryEventSequence		= py::array_t<int>();
+		_filteredSignal				= py::array_t<double>();
+		_segmentedLog				= py::array_t<double>();
+		_noiseVariance				= py::array_t<double>();
+	}
+
+	SegmentationResults::SegmentationResults(Algorithms::SegmentationResults* segmentationResults)
+	{
+		// Initial scalar values from the input.
+		_signalLength				= segmentationResults->GetSignalLength();
+		_numberOfBinaryEvents		= segmentationResults->GetNumberOfBinaryEvents();
+		_jumpSequenceVariance		= segmentationResults->GetJumpSequenceVariance();
+		_segmentDensity				= segmentationResults->GetSegmentDensity();
+		_iterations					= segmentationResults->GetIterations();
+		_error						= segmentationResults->GetError();
+
+		// Create the arrays.
+		_binaryEventSequence		= py::array_t<int>(_signalLength);
+		_filteredSignal				= py::array_t<double>(_signalLength);
+		_segmentedLog				= py::array_t<double>(_signalLength);
+		_noiseVariance				= py::array_t<double>(_signalLength);
+
+		// Get pointers to the results.  The data is private, we use the access functions.
+		int* binaryEventSequence	= segmentationResults->GetBinaryEventSequence();
+		double* filteredSignal		= segmentationResults->GetFilteredSignal();
+		double* segmentedLog		= segmentationResults->GetSegmentedLog();
+		double* noiseVariance		= segmentationResults->GetNoiseVariance();
+
+		// Get pointers to the actual data inside of the Python arrays.
+		int* binaryEventSequenceBuffer		= static_cast<int*>(_binaryEventSequence.request().ptr);
+		double* filteredSignalBuffer		= static_cast<double*>(_filteredSignal.request().ptr);
+		double* segmentedLogBuffer			= static_cast<double*>(_segmentedLog.request().ptr);
+		double* noiseVarianceBuffer			= static_cast<double*>(_noiseVariance.request().ptr);
+
+		// Copy the data to the Python data structures.
+		for (int i = 0; i < _signalLength; i++)
+		{
+			binaryEventSequenceBuffer[i]	= binaryEventSequence[i];
+			filteredSignalBuffer[i]			= filteredSignal[i];
+			segmentedLogBuffer[i]			= segmentedLog[i];
+			noiseVarianceBuffer[i]			= noiseVariance[i];
+		}
+	}
+
+	SegmentationResults::SegmentationResults(int signalLength, py::array_t<int> binaryEventSequence, int numberOfBinaryEvents, py::array_t<double> filteredSignal,
+		py::array_t<double> segmentedLog, py::array_t<double> noiseVariance, double jumpSequenceVariance, double segmentDensity, int iterations, int error)
+	{
+		_signalLength				= signalLength;
+		_binaryEventSequence		= binaryEventSequence;
+		_numberOfBinaryEvents		= numberOfBinaryEvents;
+		_filteredSignal				= filteredSignal;
+		_segmentedLog				= segmentedLog;
+		_noiseVariance				= noiseVariance;
+		_jumpSequenceVariance		= jumpSequenceVariance;
+		_segmentDensity				= segmentDensity;
+		_iterations					= iterations;
+		_error						= error;
+	}
+
+	SegmentationResults::~SegmentationResults()
+	{
+	}
+
+	int SegmentationResults::GetSignalLength() const
+	{
+		return _signalLength;
+	}
+
+	py::array_t<int> SegmentationResults::GetBinaryEventSequence() const
+	{
+		return _binaryEventSequence;
+	}
+
+	int SegmentationResults::GetNumberOfBinaryEvents() const
+	{
+		return _numberOfBinaryEvents;
+	}
+
+	py::array_t<double> SegmentationResults::GetFilteredSignal() const
+	{
+		return _filteredSignal;
+	}
+
+	py::array_t<double> SegmentationResults::GetSegmentedLog() const
+	{
+		return _segmentedLog;
+	}
+
+	py::array_t<double> SegmentationResults::GetNoiseVariance() const
+	{
+		return _noiseVariance;
+	}
+
+	double SegmentationResults::GetJumpSequenceVariance() const
+	{
+		return _jumpSequenceVariance;
+	}
+
+	double SegmentationResults::GetSegmentDensity() const
+	{
+		return _segmentDensity;
+	}
+		
+	int SegmentationResults::GetIterations() const
+	{
+		return _iterations;
+	}
+
+	int SegmentationResults::GetError() const
+	{
+		return _error;
+	}
+
+} // End namespace.

Python Extension/SegmentationResultsPy.h

@@ -0,0 +1,119 @@
+#ifndef SEGMENTATIONRESULTSPY_H
+#define SEGMENTATIONRESULTSPY_H
+
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include "SegmentationResults.h"
+
+namespace py = pybind11;
+
+namespace PythonAlgorithms
+{
+	class SegmentationResults
+	{
+		private:
+			int						_signalLength;
+			py::array_t<int>		_binaryEventSequence;
+			int						_numberOfBinaryEvents;
+			py::array_t<double>		_filteredSignal;
+			py::array_t<double>		_segmentedLog;
+			py::array_t<double>		_noiseVariance;
+			double					_jumpSequenceVariance;
+			double					_segmentDensity;
+			int						_iterations;
+			int						_error;
+
+		public:
+			/// <summary>
+			/// Default constructor.
+			/// </summary>
+			SegmentationResults();
+			
+			/// <summary>
+			/// Constructor.
+			/// </summary>
+			/// <param name="segmentationResults">SegmentationResults which will be converted for use in Python.</param>
+			SegmentationResults(Algorithms::SegmentationResults* segmentationResults);
+
+			/// <summary>
+			/// Constructor for calling from Python.
+			/// </summary>
+			/// <param name="signalLength">Length of the signal/binary event sequence/filtered signal/et cetera.</param>
+			/// <param name="binaryEventSequence">Binary event sequence.</param>
+			/// <param name="numberOfBinaryEvents">Number of binary events found (number of "1"s found in binary event sequence).</param>
+			/// <param name="filteredSignal">Filtered signal.</param>
+			/// <param name="segmentedLog">Segmented log.</param>
+			/// <param name="noiseVariance">Noise variance.</param>
+			/// <param name="jumpSequenceVariance">Jump sequence variance.</param>
+			/// <param name="segmentDensity">Segment density (ratio of events to total entries in binary event sequence).</param>
+			/// <param name="iterations">Number of iterations performed.</param>
+			/// <param name="error">Error flag.</param>
+			SegmentationResults(int signalLength, py::array_t<int> binaryEventSequence, int numberOfBinaryEvents, py::array_t<double> filteredSignal, py::array_t<double> segmentedLog, 
+				py::array_t<double> noiseVariance, double jumpSequenceVariance, double segmentDensity, int iterations, int error);
+
+			/// <summary>
+			/// destructor.
+			/// </summary>
+			~SegmentationResults();
+
+		public:
+			/// <summary>
+			/// Length of the input signal.  The output sequences are the name length.
+			/// </summary>
+			int GetSignalLength() const;
+
+			/// <summary>
+			/// Array that contains 1s at segmented log boundaries and 0s elsewhere.
+			/// </summary>
+			py::array_t<int> GetBinaryEventSequence() const;
+
+			/// <summary>
+			/// Number of binary event sequences detected (number of "1"s in the BinaryEventSequence array).
+			/// </summary>
+			int GetNumberOfBinaryEvents() const;
+
+			/// <summary>
+			/// Filtered estimate of the signal.
+			/// </summary>
+			py::array_t<double> GetFilteredSignal() const;
+
+			/// <summary>
+			/// Average of filter log for each segment.
+			/// </summary>
+			py::array_t<double> GetSegmentedLog() const;
+
+			/// <summary>
+			/// Estimate noise variance.
+			/// </summary>
+			py::array_t<double> GetNoiseVariance() const;
+
+			/// <summary>
+			/// Estimated variance of the jump sequence.
+			/// </summary>
+			double GetJumpSequenceVariance() const;
+
+			/// <summary>
+			/// Estimate segment density.
+			/// </summary>
+			double GetSegmentDensity() const;
+		
+			/// <summary>
+			/// SMLR iteration count.
+			/// </summary>
+			int GetIterations() const;
+
+			/// <summary>
+			/// Error flag.
+			///		Zero - no error.
+			///		Less than zero - invalid event density estimated after threshold.  Reduce/increase
+			///			threshold and rerun.
+			///		Greater than zero - logarithm argument became zero at sample number returned in error during
+			///			the calculation of likelihood ratios in SMLR.  There may be more samples of this type which
+			///			may give rise to this problem.  Edit/rescale data values and rerun.
+			/// </summary>
+			int GetError() const;
+
+	}; // End class.
+} // End namespace.
+
+#endif

Python Extension/module.cpp

@@ -0,0 +1,140 @@
+#include <stdexcept>
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+//#include <pybind11/stl.h>
+
+#include "SegmentSignalFunctions.h"
+#include "SegmentSignal.h"
+#include "SegmentationResults.h"
+#include "SegmentationResultsPy.h"
+
+#include <iostream>
+#include <fstream>
+#include <iomanip>      // std::setprecision
+
+namespace py = pybind11;
+
+PythonAlgorithms::SegmentationResults* Segment(py::array_t<double> signalAsPyList, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, int noiseVarianceEstimateMethod, int maxSMLRIterations)
+{
+	// Gets the information about the object and a pointer to the actual data (buffer).
+    py::buffer_info info		= signalAsPyList.request();
+    double* signalDataPointer	= static_cast<double*>(info.ptr);
+
+	// Make sure a 1-dimensional array/list was passed and not a scalar, two-dimensional, or other.
+	if (info.ndim != 1)
+	{
+		throw std::runtime_error("Error: The array passed to \"Segment\" function is not 1 dimensional.");
+	}
+
+	// Get the length of the array/list.  It is required for the lower level functions operation on C arrays.
+	int signalLength = static_cast<int>(info.shape[0]);
+
+	// Call the algorithm, then convert the results for returning to Python.
+    Algorithms::SegmentationResults*		cppResults		= Algorithms::SegmentSignal::Segment(signalDataPointer, signalLength, threshold, jumpSequenceWindowSize, noiseVarianceWindowSize, (NoiseVarianceEstimateMethod)noiseVarianceEstimateMethod, maxSMLRIterations);
+    PythonAlgorithms::SegmentationResults*	pythonResults	= new PythonAlgorithms::SegmentationResults(cppResults);
+	
+	// The C results are not longer needed.  Everything has been copied to the Python results.
+	delete cppResults;
+
+    return pythonResults;
+}
+
+
+py::array_t<int> FindSignificantZones(py::array_t<int> binaryEvents, py::array_t<double> xData, double threshold, bool includeBoundaries)
+{
+	// Gets the information about the object and a pointer to the actual data (buffer).
+	py::buffer_info eventsInfo	= binaryEvents.request();
+	int* binaryEventsPointer	= static_cast<int*>(eventsInfo.ptr);
+	py::buffer_info xDataInfo	= xData.request();
+	double* xDataPointer		= static_cast<double*>(xDataInfo.ptr);
+
+	// Make sure a 1-dimensional array/list was passed and not a scalar, two-dimensional, or other.
+	if (eventsInfo.ndim != 1 || xDataInfo.ndim != 1)
+	{
+		throw std::runtime_error("Error: An array passed to \"FindSignificantZones\" function is not 1 dimensional.");
+	}
+
+	// Make sure a data is the same length.
+	if (eventsInfo.shape[0] != xDataInfo.shape[0])
+	{
+		throw std::runtime_error("Error: Arrays passed to \"FindSignificantZones\" function are not the same length.");
+	}
+
+	// Get the length of the array/list.  It is required for the lower level functions operation on C arrays.
+	int signalLength							= static_cast<int>(eventsInfo.shape[0]);
+	std::vector<std::array<int, 2>>* cppResults = Algorithms::SegmentSignal::FindSignificantZones(binaryEventsPointer, xDataPointer, signalLength, threshold, includeBoundaries);
+
+	size_t size					= cppResults->size();
+	py::array_t<int> pyResults	= py::array_t<int>(2*size);
+	int* pyResultsBuffer		= static_cast<int*>(pyResults.request().ptr);
+
+	for (int i = 0; i < size; i++)
+	{
+		std::array<int, 2> indexSet	= (*cppResults)[i];
+		pyResultsBuffer[2*i]		= indexSet[0];
+		pyResultsBuffer[2*i+1]		= indexSet[1];
+	}
+	
+	pyResults.resize({(int)size, 2});
+
+	delete cppResults;
+
+	return pyResults;
+}
+
+
+PYBIND11_MODULE(SegmentSignalPy, m)
+{
+    m.def("Segment", &Segment, "Segments a signal based on maximum likelihood estimation");
+
+	m.def("FindSignificantZones", &FindSignificantZones, "Post processes a binary event sequence to find regions that are greater than the specified threashold.");
+
+    //py::class_<Algorithms::SegmentSignal>(m, "SegmentSignal")
+    //    .def_static("Segment", static_cast<Algorithms::SegmentationResults* (*)(double[], int, double, int, int)>(&Algorithms::SegmentSignal::Segment));
+
+    py::class_<PythonAlgorithms::SegmentationResults>(m, "SegmentationResults")
+        .def(py::init<>())
+		.def(py::init<int, py::array_t<int>, int, py::array_t<double>, py::array_t<double>, py::array_t<double>, double, double, int, int>())
+		.def(py::pickle(
+			[](const PythonAlgorithms::SegmentationResults& p) { // __getstate__
+				// Return a tuple that fully encodes the state of the object.
+				return py::make_tuple(p.GetSignalLength(), p.GetBinaryEventSequence(), p.GetNumberOfBinaryEvents(), p.GetFilteredSignal(), p.GetSegmentedLog(), p.GetNoiseVariance(), p.GetJumpSequenceVariance(), p.GetSegmentDensity(), p.GetIterations(), p.GetError());
+			},
+			[](py::tuple t) { // __setstate__
+				if (t.size() != 10)
+					throw std::runtime_error("Invalid state!");
+
+				// Create a new C++ instance.
+				PythonAlgorithms::SegmentationResults p(
+					t[0].cast<int>(),						// Signal length.
+					t[1].cast<py::array_t<int>>(),			// Binary event sequence.
+					t[2].cast<int>(),						// Number of binary events.
+					t[3].cast<py::array_t<double>>(),		// Filtered signal.
+					t[4].cast<py::array_t<double>>(),		// Segmented log.
+					t[5].cast<py::array_t<double>>(),		// Noise variance.
+					t[6].cast<double>(),					// Noise variance jump sequence.
+					t[7].cast<double>(),					// Segment density.
+					t[8].cast<int>(),						// Iterations.
+					t[9].cast<int>()						// Error.
+				);
+
+				return p;
+			}
+		))
+		.def_property_readonly("SignalLength",			&PythonAlgorithms::SegmentationResults::GetSignalLength)
+		.def_property_readonly("BinaryEventSequence",	&PythonAlgorithms::SegmentationResults::GetBinaryEventSequence)
+        .def_property_readonly("NumberOfBinaryEvents",	&PythonAlgorithms::SegmentationResults::GetNumberOfBinaryEvents)
+        .def_property_readonly("FilteredSignal",		&PythonAlgorithms::SegmentationResults::GetFilteredSignal)
+        .def_property_readonly("SegmentedLog",			&PythonAlgorithms::SegmentationResults::GetSegmentedLog)
+        .def_property_readonly("NoiseVariance",			&PythonAlgorithms::SegmentationResults::GetNoiseVariance)
+        .def_property_readonly("JumpSequenceVariance",	&PythonAlgorithms::SegmentationResults::GetJumpSequenceVariance)
+        .def_property_readonly("SegmentDensity",		&PythonAlgorithms::SegmentationResults::GetSegmentDensity)
+        .def_property_readonly("Iterations",			&PythonAlgorithms::SegmentationResults::GetIterations)
+        .def_property_readonly("Error",					&PythonAlgorithms::SegmentationResults::GetError);
+
+    #ifdef VERSION_INFO
+        m.attr("__version__") = VERSION_INFO;
+    #else
+        m.attr("__version__") = "dev";
+    #endif
+}