SegmentSignalPy 0.1.3__cp313-cp313-win_amd64.whl

C DLL/DLLExport.h

@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include "SegmentSignalFunctions.h"
+
+extern "C"
+{
+	// Export our function to a DLL and handle some pointer/addresses handling.
+	__declspec(dllexport) void SegmentSignalWrapper(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)
+	{
+		SegmentSignal(LOG, NSAMPS, F, ORDER, ORDER1, RMODE, NITER, Q, *NQ, FLTLOG, SEGLOG, R, *C, *D, *NACT, *IER);
+	}
+}

CPP Static Library/NoiseVarianceEstimateMethod.h

@@ -0,0 +1,17 @@
+#ifndef NOISEVARIANCEESTIMATEMETHOD_H
+#define NOISEVARIANCEESTIMATEMETHOD_H
+
+enum class NoiseVarianceEstimateMethod
+{
+	/// <summary>Point estimate.</summary>
+	Point           = 0,
+
+	/// <summary>Smoothed estimate.</summary>
+	Smoothed        = 1,
+
+	/// <summary>The number of types/items in the enumeration.</summary>
+	Length
+
+}; // End enum.
+
+#endif

CPP Static Library/SegmentSignal.cpp

@@ -0,0 +1,167 @@
+#include "SegmentSignal.h"
+#include "NoiseVarianceEstimateMethod.h"
+#include "SegmentSignalFunctions.h"
+#include <vector>
+#include <cmath>
+
+using namespace std;
+
+namespace Algorithms
+{
+	SegmentationResults* SegmentSignal::Segment(double signal[], int signalLength, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize)
+	{
+		return Segment(signal, signalLength, threshold, jumpSequenceWindowSize, noiseVarianceWindowSize, NoiseVarianceEstimateMethod::Point, 300);
+	}
+
+	SegmentationResults* SegmentSignal::Segment(double signal[], int signalLength, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, NoiseVarianceEstimateMethod noiseVarianceEstimateMethod)
+	{
+		return Segment(signal, signalLength, threshold, jumpSequenceWindowSize, noiseVarianceWindowSize, noiseVarianceEstimateMethod, 300);
+	}
+
+	SegmentationResults* SegmentSignal::Segment(double signal[], int signalLength, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, NoiseVarianceEstimateMethod noiseVarianceEstimateMethod, int maxSMLRIterations)
+	{
+		// Scalars which are need for output from the call to the algorithm.
+		int		numberOfBinaryEvents	= 0;
+		double	jumpSequenceVariance	= 0;
+		double	segmentDensity			= 0;
+		int		iterations				= 0;
+		int		error					= 0;
+
+		// We seem to need to create the array in the function immediately prior to calling the unmanaged code, otherwise the garbage collector
+		// gets cute and moves things around, which the unmanaged code takes offense to.
+		//double* signalToPass = new double[signalLength];
+		//for (int i = 0; i < signalLength; i++)
+		//{
+		//	signalToPass[i] = signal[i];
+		//}
+
+
+		// Create the output arrays.  After being populated by the call to the algorithm they are grouped, stored, and returned in the SegmenationResults data structure.
+		int* Q			= new int[signalLength];		// Binary event sequence.
+		double* FLTLOG	= new double[signalLength];		// Filtered signal.
+		double* SEGLOG	= new double[signalLength];		// Segmented log.
+		double* R		= new double[signalLength];		// Noise variance.
+
+		// Function call to the C DLL.
+		::SegmentSignal(signal, signalLength, threshold, jumpSequenceWindowSize, noiseVarianceWindowSize, (int)noiseVarianceEstimateMethod, maxSMLRIterations, Q, numberOfBinaryEvents, FLTLOG, SEGLOG, R, jumpSequenceVariance, segmentDensity, iterations, error);
+
+		return new SegmentationResults(signalLength, Q, numberOfBinaryEvents, FLTLOG, SEGLOG, R, jumpSequenceVariance, segmentDensity, iterations, error);
+	}
+
+	SegmentationResults* SegmentSignal::Segment(vector<double> signal, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize)
+	{
+		return Segment(signal, threshold, jumpSequenceWindowSize, noiseVarianceWindowSize, NoiseVarianceEstimateMethod::Point, 300);
+	}
+
+	SegmentationResults* SegmentSignal::Segment(vector<double> signal, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, NoiseVarianceEstimateMethod noiseVarianceEstimateMethod)
+	{
+		return Segment(signal, threshold, jumpSequenceWindowSize, noiseVarianceWindowSize, noiseVarianceEstimateMethod, 300);
+	}
+
+	SegmentationResults* SegmentSignal::Segment(vector<double> signal, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, NoiseVarianceEstimateMethod noiseVarianceEstimateMethod, int maxSMLRIterations)
+	{
+		// Scalars which are need for output from the call to the algorithm.
+		int		numberOfBinaryEvents	= 0;
+		double	jumpSequenceVariance	= 0;
+		double	segmentDensity			= 0;
+		int		iterations				= 0;
+		int		error					= 0;
+	
+		int signalLength		= (int)signal.size();
+		double* signalToPass	= new double[signalLength];
+		for (int i = 0; i < signalLength; i++)
+		{
+			signalToPass[i] = signal[i];
+		}
+
+		// Create the output arrays.  After being populated by the call to the algorithm they are grouped, stored, and returned in the SegmenationResults data structure.
+		int* Q			= new int[signalLength];		// Binary event sequence.
+		double* FLTLOG	= new double[signalLength];		// Filtered signal.
+		double* SEGLOG	= new double[signalLength];		// Segmented log.
+		double* R		= new double[signalLength];		// Noise variance.
+
+
+		int estimateMethod	= (int)noiseVarianceEstimateMethod;
+
+		// Function call to the C DLL.
+		::SegmentSignal(signalToPass, signalLength, threshold, jumpSequenceWindowSize, noiseVarianceWindowSize, estimateMethod, maxSMLRIterations, Q, numberOfBinaryEvents, FLTLOG, SEGLOG, R, jumpSequenceVariance, segmentDensity, iterations, error);
+
+		return new SegmentationResults(signalLength, Q, numberOfBinaryEvents, FLTLOG, SEGLOG, R, jumpSequenceVariance, segmentDensity, iterations, error);
+	}
+
+	vector<array<int, 2>>* SegmentSignal::FindSignificantZones(int binaryEvents[], double xData[], int signalLength, double threshold)
+	{
+		return FindSignificantZones(binaryEvents, xData, signalLength, threshold, false);
+	}
+
+	vector<array<int, 2>>* SegmentSignal::FindSignificantZones(int binaryEvents[], double xData[], int signalLength, double threshold, bool includeBoundaries)
+	{
+		vector<array<int, 2>>* significantZones = new vector<array<int, 2>>();
+
+		// Find the first "0" entry which will mark the beginning of a zone.
+		int zoneStart = FindNextZero(binaryEvents, signalLength, 0);
+
+		for (int currentIndex = zoneStart+1; currentIndex < signalLength; currentIndex++)
+		{
+			if (binaryEvents[currentIndex])
+			{
+				CheckIfValidZone(xData, threshold, includeBoundaries, significantZones, zoneStart, currentIndex-1);
+
+				// Scan for the start of the next potential section.
+				zoneStart = FindNextZero(binaryEvents, signalLength, currentIndex);
+				currentIndex = zoneStart;
+			}
+		}
+
+		// If the last entry of the binary events is zero, we need to handle the final section.
+		if (!binaryEvents[signalLength-1])
+		{
+			CheckIfValidZone(xData, threshold, includeBoundaries, significantZones, zoneStart, signalLength-1);
+		}
+
+		// When including the boundaries (includeBoundaries==true), it is possible to have added data points before the beginning of the array
+		// and after the end.  We need to check for and, if they exist, correct them.
+		if (significantZones->size() > 0)
+		{
+			if ((*significantZones)[0][0] < 0)
+			{
+				(*significantZones)[0][0] = 0;
+			}
+
+			if ((*significantZones)[significantZones->size()-1][1] >= signalLength)
+			{
+				(*significantZones)[significantZones->size()-1][1] = signalLength-1;
+			}
+		}
+
+		return significantZones;
+	}
+
+	int SegmentSignal::FindNextZero(int binaryEvents[], int signalLength, int currentIndex)
+	{
+		// Find the first zero.
+		while (binaryEvents[currentIndex] && currentIndex < signalLength-1)
+		{
+			currentIndex++;
+		}
+		return currentIndex;
+	}
+
+	void SegmentSignal::CheckIfValidZone(double xData[], double threshold, bool includeBoundaries, vector<array<int, 2>>* significantZones, int startIndex, int endIndex)
+	{
+		// Check to see if the threshold is met.  If it met, we will store the section
+		// as a significant zone.  If the threshold is not met, then the zone is not long
+		// enough so it is ignored and we scan ahead.
+		if (abs(xData[endIndex] - xData[startIndex]) > threshold)
+		{
+			if (includeBoundaries)
+			{
+				significantZones->push_back({ {startIndex-1, endIndex+1} });
+			}
+			else
+			{
+				significantZones->push_back({{startIndex, endIndex}});
+			}
+		}
+	}
+} // End namespace.

CPP Static Library/SegmentSignal.h

@@ -0,0 +1,195 @@
+#ifndef SEGMENTSIGNAL_H
+#define SEGMENTSIGNAL_H
+
+#include "NoiseVarianceEstimateMethod.h"
+#include "SegmentationResults.h"
+#include <vector>
+#include <array>
+
+using namespace std;
+
+namespace Algorithms
+{
+	/// <summary>
+	/// C++ interface for the C code.
+	/// </summary>
+	class SegmentSignal
+	{
+		public:
+			/// <summary>
+			/// Segment a signal using the Maximum Likelihood Estimation of Radhakrishnan, et al, 1991.  Attempts to identify regions of the signal that are
+			/// considered "consistent."  Assumes a signal that has a state which changes only at segment boundaries.  The state change can be random and the
+			/// noise on top of the signal is modeled as Gaussian, but not necessarily stationary.
+			/// 
+			/// Assumes a point estimate of the noise variance and an upper bound of 300 on the number of Single Most Likelihood Replacement iterations.
+			/// </summary>
+			/// <param name="signal">Input signal to be segmented.</param>
+			/// <param name="signalLength">Input signal to be segmented.</param>
+			/// <param name="threshold">Segmentation threshold.</param>
+			/// <param name="jumpSequenceWindowSize">Length of the moving average window sized used for smoothing the input well log to arrive at an initial estimate of the jump sequence variance.</param>
+			/// <param name="noiseVarianceWindowSize">Length of the moving average window used for smoothing the noise variances.</param>
+			/// <param name="noiseVarianceEstimateMethod">
+			/// Noise variance estimate option.
+			//		rmode = 0 ==> Point estimate of noise variance.
+			//		rmode = 1 ==> Noise estimates smoothed within segments.
+			/// </param>
+			/// <returns>A SegmentationResults instance which contains the algorithm output of binary events, segmented log, filtered log, et cetera.</returns>
+			static SegmentationResults* Segment(double signal[], int signalLength, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize);
+
+			/// <summary>
+			/// Segment a signal using the Maximum Likelihood Estimation of Radhakrishnan, et al, 1991.  Attempts to identify regions of the signal that are
+			/// considered "consistent."  Assumes a signal that has a state which changes only at segment boundaries.  The state change can be random and the
+			/// noise on top of the signal is modeled as Gaussian, but not necessarily stationary.
+			/// 
+			/// Assumes an upper bound of 300 on the number of Single Most Likelihood Replacement iterations.
+			/// </summary>
+			/// <param name="signal">Input signal to be segmented.</param>
+			/// <param name="signalLength">Input signal to be segmented.</param>
+			/// <param name="threshold">Segmentation threshold.</param>
+			/// <param name="jumpSequenceWindowSize">Length of the moving average window sized used for smoothing the input well log to arrive at an initial estimate of the jump sequence variance.</param>
+			/// <param name="noiseVarianceWindowSize">Length of the moving average window used for smoothing the noise variances.</param>
+			/// <param name="noiseVarianceEstimateMethod">
+			/// Noise variance estimate option.
+			//		rmode = 0 ==> Point estimate of noise variance.
+			//		rmode = 1 ==> Noise estimates smoothed within segments.
+			/// </param>
+			/// <returns>A SegmentationResults instance which contains the algorithm output of binary events, segmented log, filtered log, et cetera.</returns>
+			static SegmentationResults* Segment(double signal[], int signalLength, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, NoiseVarianceEstimateMethod noiseVarianceEstimateMethod);
+
+			/// <summary>
+			/// Segment a signal using the Maximum Likelihood Estimation of Radhakrishnan, et al, 1991.  Attempts to identify regions of the signal that are
+			/// considered "consistent."  Assumes a signal that has a state which changes only at segment boundaries.  The state change can be random and the
+			/// noise on top of the signal is modeled as Gaussian, but not necessarily stationary.
+			/// </summary>
+			/// <param name="signal">Input signal to be segmented.</param>
+			/// <param name="signalLength">Input signal to be segmented.</param>
+			/// <param name="threshold">Segmentation threshold.</param>
+			/// <param name="jumpSequenceWindowSize">Length of the moving average window sized used for smoothing the input well log to arrive at an initial estimate of the jump sequence variance.</param>
+			/// <param name="noiseVarianceWindowSize">Length of the moving average window used for smoothing the noise variances.</param>
+			/// <param name="noiseVarianceEstimateMethod">
+			/// Noise variance estimate option.
+			//		rmode = 0 ==> Point estimate of noise variance.
+			//		rmode = 1 ==> Noise estimates smoothed within segments.
+			/// </param>
+			/// <param name="maxSMLRIterations">Upper bound on the number of Single Most Likelihood Replacement iterations.</param>
+			/// <returns>A SegmentationResults instance which contains the algorithm output of binary events, segmented log, filtered log, et cetera.</returns>
+			static SegmentationResults* Segment(double signal[], int signalLength, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, NoiseVarianceEstimateMethod noiseVarianceEstimateMethod, int maxSMLRIterations);
+
+			/// <summary>
+			/// Segment a signal using the Maximum Likelihood Estimation of Radhakrishnan, et al, 1991.  Attempts to identify regions of the signal that are
+			/// considered "consistent."  Assumes a signal that has a state which changes only at segment boundaries.  The state change can be random and the
+			/// noise on top of the signal is modeled as Gaussian, but not necessarily stationary.
+			/// 
+			/// Assumes a point estimate of the noise variance and an upper bound of 300 on the number of Single Most Likelihood Replacement iterations.
+			/// </summary>
+			/// <param name="signal">Input signal to be segmented.</param>
+			/// <param name="threshold">Segmentation threshold.</param>
+			/// <param name="jumpSequenceWindowSize">Length of the moving average window sized used for smoothing the input well log to arrive at an initial estimate of the jump sequence variance.</param>
+			/// <param name="noiseVarianceWindowSize">Length of the moving average window used for smoothing the noise variances.</param>
+			/// <param name="noiseVarianceEstimateMethod">
+			/// Noise variance estimate option.
+			//		rmode = 0 ==> Point estimate of noise variance.
+			//		rmode = 1 ==> Noise estimates smoothed within segments.
+			/// </param>
+			/// <returns>A SegmentationResults instance which contains the algorithm output of binary events, segmented log, filtered log, et cetera.</returns>
+			static SegmentationResults* Segment(vector<double> signal, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize);
+
+			/// <summary>
+			/// Segment a signal using the Maximum Likelihood Estimation of Radhakrishnan, et al, 1991.  Attempts to identify regions of the signal that are
+			/// considered "consistent."  Assumes a signal that has a state which changes only at segment boundaries.  The state change can be random and the
+			/// noise on top of the signal is modeled as Gaussian, but not necessarily stationary.
+			/// 
+			/// Assumes an upper bound of 300 on the number of Single Most Likelihood Replacement iterations.
+			/// </summary>
+			/// <param name="signal">Input signal to be segmented.</param>
+			/// <param name="threshold">Segmentation threshold.</param>
+			/// <param name="jumpSequenceWindowSize">Length of the moving average window sized used for smoothing the input well log to arrive at an initial estimate of the jump sequence variance.</param>
+			/// <param name="noiseVarianceWindowSize">Length of the moving average window used for smoothing the noise variances.</param>
+			/// <param name="noiseVarianceEstimateMethod">
+			/// Noise variance estimate option.
+			//		rmode = 0 ==> Point estimate of noise variance.
+			//		rmode = 1 ==> Noise estimates smoothed within segments.
+			/// </param>
+			/// <returns>A SegmentationResults instance which contains the algorithm output of binary events, segmented log, filtered log, et cetera.</returns>
+			static SegmentationResults* Segment(vector<double> signal, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, NoiseVarianceEstimateMethod noiseVarianceEstimateMethod);
+
+			/// <summary>
+			/// Segment a signal using the Maximum Likelihood Estimation of Radhakrishnan, et al, 1991.  Attempts to identify regions of the signal that are
+			/// considered "consistent."  Assumes a signal that has a state which changes only at segment boundaries.  The state change can be random and the
+			/// noise on top of the signal is modeled as Gaussian, but not necessarily stationary.
+			/// </summary>
+			/// <param name="signal">Input signal to be segmented.</param>
+			/// <param name="threshold">Segmentation threshold.</param>
+			/// <param name="jumpSequenceWindowSize">Length of the moving average window sized used for smoothing the input well log to arrive at an initial estimate of the jump sequence variance.</param>
+			/// <param name="noiseVarianceWindowSize">Length of the moving average window used for smoothing the noise variances.</param>
+			/// <param name="noiseVarianceEstimateMethod">
+			/// Noise variance estimate option.
+			//		rmode = 0 ==> Point estimate of noise variance.
+			//		rmode = 1 ==> Noise estimates smoothed within segments.
+			/// </param>
+			/// <param name="maxSMLRIterations">Upper bound on the number of Single Most Likelihood Replacement iterations.</param>
+			/// <returns>A SegmentationResults instance which contains the algorithm output of binary events, segmented log, filtered log, et cetera.</returns>
+			static SegmentationResults* Segment(vector<double> signal, double threshold, int jumpSequenceWindowSize, int noiseVarianceWindowSize, NoiseVarianceEstimateMethod noiseVarianceEstimateMethod, int maxSMLRIterations);
+
+			/// <summary>
+			/// Creates a list of indexes which indicate where the "significant zones" are in the results of the segmentation.  A significant
+			/// zone is defined as a region between binary events (for example 1,0,0,0,1 is a region/zone of 3) that are longer than the
+			/// specified threshold.
+			/// 
+			/// An example use for this algorithm would to be to first run the segmentation algorithm on the log/signal to get the results, then
+			/// use this algorithm to find the regions of interest.
+			/// 
+			/// Since a log/signal fed to the segmentation algorithm is the dependent values (y values of a plot), the independent (x values)
+			/// must be supplied to this algorithm to enable evaluate the "length" of each zone.
+			/// </summary>
+			/// <param name="binaryEvents">Array of binary events (1s and 0s) which specify the boundaries of each zone.</param>
+			/// <param name="xData">Independent values associated with the log/signal fed to the Segment algorithm and produced the SegmentationResults.</param>
+			/// <param name="signalLength">Input signal to be segmented.</param>
+			/// <param name="threshold">Length a zone must be to be consider "significant."  Zones shorter than this are ignored.</param>
+			/// <returns>A vector of arrays of length 2 indicating the zones.  Each entry in the List is a pair indicating the starting and ending index of one significant zone.</returns>
+			static vector<array<int, 2>>* FindSignificantZones(int binaryEvents[], double xData[], int signalLength, double threshold);
+
+			/// <summary>
+			/// Creates a list of indexes which indicate where the "significant zones" are in the results of the segmentation.  A significant
+			/// zone is defined as a region between binary events (for example 1,0,0,0,1 is a region/zone of 3) that are longer than the
+			/// specified threshold.
+			/// 
+			/// An example use for this algorithm would to be to first run the segmentation algorithm on the log/signal to get the results, then
+			/// use this algorithm to find the regions of interest.
+			/// 
+			/// Since a log/signal fed to the segmentation algorithm is the dependent values (y values of a plot), the independent (x values)
+			/// must be supplied to this algorithm to enable evaluate the "length" of each zone.
+			/// </summary>
+			/// <param name="binaryEvents">Array of binary events (1s and 0s) which specify the boundaries of each zone.</param>
+			/// <param name="xData">Independent values associated with the log/signal fed to the Segment algorithm and produced the SegmentationResults.</param>
+			/// <param name="signalLength">Input signal to be segmented.</param>
+			/// <param name="threshold">Length a zone must be to be consider "significant."  Zones shorter than this are ignored.</param>
+			/// <param name="includeBoundaries">If true, the end data points are added as part of the zone.  Does not change how zones are found.</param>
+			/// <returns>A vector of arrays of length 2 indicating the zones.  Each entry in the List is a pair indicating the starting and ending index of one significant zone.</returns>
+			static vector<array<int, 2>>* FindSignificantZones(int binaryEvents[], double xData[], int signalLength, double threshold, bool includeBoundaries);
+
+		private:
+			/// <summary>
+			/// Scans the binary events for the next zero.  Helper function to FindSignificantZones.
+			/// </summary>
+			/// <param name="binaryEvents">Binary event sequence array.</param>
+			/// <param name="signalLength">Input signal to be segmented.</param>
+			/// <param name="currentIndex">Index to start scanning from.</param>
+			/// <returns>Index of next zero.</returns>
+			static int FindNextZero(int binaryEvents[], int signalLength, int currentIndex);
+
+			/// <summary>
+			/// Checks to see if the threshold for being a significant zone is met.  If it is, it is added to the list of significant zones.
+			/// </summary>
+			/// <param name="xData">Independent values associated with the log/signal fed to the Segment algorithm and produced the SegmentationResults.</param>
+			/// <param name="threshold">Length a zone must be to be consider "significant."  Zones shorter than this are ignored.</param>
+			/// <param name="includeBoundaries">If true, the end data points are added as part of the zone.  Does not change how zones are found.</param>
+			/// <param name="significantZones">List of significant zones.</param>
+			/// <param name="startIndex">Starting index of zone.</param>
+			/// <param name="endIndex">Ending index of the zone.</param>
+			static void CheckIfValidZone(double xData[], double threshold, bool includeBoundaries, vector<array<int, 2>>* significantZones, int startIndex, int endIndex);
+
+	}; // End class.
+} // End namespace.
+
+#endif