SegmentSignalPy 0.1.2__cp312-cp312-win_amd64.whl

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/SegmentSignalFunctions.cpp

@@ -0,0 +1,797 @@
+#include "SegmentSignalFunctions.h"
+#include <stdlib.h>
+#include <math.h>
+#include <windows.h>
+#include <malloc.h>
+#include <stdexcept>
+
+// Original function name: LOGSEG
+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)
+{
+	// Function:
+	// Maximum Likelihood Segmentation
+	//
+	// Input parameters:
+	// LOG: Input discretized well log.
+	//
+	// NSAMPS: Number of samples in array log.
+	//
+	// F: Segmentation threshold index.
+	//
+	// ORDER: Length of the moving average window used for smoothing the input well
+	//			log to arrive at an initial estimate of jump sequence variance, C.
+	//
+	// ORDER1: Length of the moving average window used for smoothing the noise variances.
+	//
+	// RMODE: Noise variance estimate option.
+	//		RMODE = 0 ==> Point estimate of noise variance.
+	//		RMODE = 1 ==> Noise estimates smoothed within segments.
+	//
+	// NITER: Upper bound on the number of SingleMostLikelihoodReplacement iterations.
+	//
+	// Output parameters:
+	// Q: Binary event sequence.
+	//
+	// NQ: Number of binary events found (number of "1"s in Q).
+	//
+	// FLTLOG: Filtered estimate of the signal.  Also used as intermediate work array.
+	//
+	// SEGLOG: FLTLOG averaged over each segment.
+	//
+	// R: Estimated noise variance.
+	//
+	// C: Estimated variance of the jump sequence.
+	//
+	// D: Estimated segment density.
+	//
+	// NACT: Actual SingleMostLikelihoodReplacement iteration count.
+	//
+	// IER: Error flag.
+	//		IER = 0 ==> No error.
+	//		IER < 0 ==> Invalid event density estimated	after threshold.  Reduce/increase F and rerun.
+	//		IER > 0 ==> Logarithm argument became zero at sample number IER during the calculation of
+	//			likelihood ratios in SingleMostLikelihoodReplacement.  There may be more samples of this type which may give rise
+	//			to this problem.  Edit/rescale data values and rerun.
+
+	// Check input.
+	if (ORDER > NSAMPS || ORDER1 > NSAMPS)
+	{
+		throw std::runtime_error("SegmentSignal Error: The window sizes cannot exceed the signal length.");
+	}
+	
+	// Intermediate work arrays.
+	double* WORK1 = (double*)malloc(NSAMPS * sizeof(double));
+	double* WORK2 = (double*)malloc(NSAMPS * sizeof(double));
+
+	int HORDER	= ORDER / 2;
+	int NORDER	= ORDER1 / 2;
+
+	// Ensure we did not round to 0.
+	if (HORDER < 1)
+	{
+		HORDER = 1;
+	}
+
+	if (NORDER < 1)
+	{
+		NORDER = 1;
+	}
+
+	int VMODE	= 0;
+	bool CONV	= false;
+	int ITER	= 0;
+
+	double MEAN		= 0.0;
+	double LBOUND	= 0.1E-04;
+	double UBOUND	= 0.98;
+
+	// Smooth input log using an HORDER point moving average (HORDER is number of points).
+	MovingAverage(LOG, NSAMPS, HORDER, SEGLOG);
+
+	// Initial estimate of c the variance of the jump sequence.
+	EstimateVarianceOfJumpSequence(SEGLOG, NSAMPS, WORK1, C);
+
+	// Estimate R, the variance of the noise.
+	for (int i = 0; i < NSAMPS; i++)
+	{
+		SEGLOG[i] = (LOG[i]-SEGLOG[i]) * (LOG[i]-SEGLOG[i]);
+	}
+
+	// Smooth the variance of the noise using an NORDER point moving average.
+	MovingAverage(SEGLOG, NSAMPS, NORDER, R);
+
+	// Bootstrap event sequence.
+	for (int i = 0; i < 2; i++)
+	{
+		// Initialize event sequence Q.
+		for (int j = 0; j < NSAMPS; j++)
+		{
+			Q[j] = 1;
+		}
+		
+		// Invoke fixed interval optimal smoother to estimate the jump sequence, residual state, and its variance.
+		KalmanFilter(LOG, Q, C, R, NSAMPS, WORK2, WORK1, SEGLOG, FLTLOG);
+		
+		FixedIntervalOptimalSmoother(Q, NSAMPS, C, SEGLOG, WORK1, WORK2);
+
+		// Re-estimate the variance of the jump sequence C.
+		CalculateMeanAndVariance(SEGLOG, NSAMPS, VMODE, MEAN, C);
+		
+		// Invoke threshold detector and update the event sequence.
+		Threshold(SEGLOG, C, F, NSAMPS, Q, D);
+
+		// Deglitch the event sequence Q.
+		Deglitch(NSAMPS, Q);
+		
+		// Update d, the event density.
+		EstimateEventDensity(Q, NSAMPS, D, NQ);
+		C = C / D;
+		
+		// Deglitch and re-estimate R, the variance of noise.
+		DeglitchAndEstimateNoiseVariance(LOG, Q, NSAMPS, RMODE, SEGLOG, R);
+	}
+
+	// Trap event density if invalid.
+	if (D <= LBOUND || D >= UBOUND)
+	{
+		IER = -1;
+	}
+	else
+	{
+		// Start Single Most Likelihood Replacement iterations.
+		do
+		{
+			// Increment iteration counter.
+			ITER++;
+
+			// Invoke fixed interval optimal smoother to estimate jump sequence, residual state, and its variance.
+			KalmanFilter(LOG, Q, C, R, NSAMPS, WORK2, WORK1, SEGLOG, FLTLOG);
+
+			FixedIntervalOptimalSmoother(Q, NSAMPS, C, SEGLOG, WORK1, WORK2);
+
+			// Invoke Single Most Likelihood Replacement detector.
+			SingleMostLikelihoodReplacement(WORK2, WORK1, C, NSAMPS, D, Q, CONV, IER);
+
+			// Update event density d.
+			EstimateEventDensity(Q, NSAMPS, D, NQ);
+
+		}
+		// Check for SingleMostLikelihoodReplacement termination.
+		while (ITER < NITER && !CONV && IER == 0);
+
+		NACT = ITER;
+
+		// Re-run KalmanFilter filter to estimate the filtered log if SingleMostLikelihoodReplacement did not converge.
+		if (CONV != 1 && IER == 0)
+		{
+			KalmanFilter(LOG, Q, C, R, NSAMPS, WORK2, WORK1, SEGLOG, FLTLOG);
+		}
+		// Average filtered log over segments.
+		AverageArraySegments(FLTLOG, Q, NSAMPS, SEGLOG);
+	}
+
+	// Free memory.
+	free(WORK1);
+	free(WORK2);
+}
+
+// Original function name: SMLR
+void SingleMostLikelihoodReplacement(double G[], double S[], double C, int NSAMPS, double D, int Q[], bool& CONV, int& IER)
+{
+	// Function:
+	// Single most likelihood replacement detector for updating an event sequence Q(k).
+	//
+	// Input parameters:
+	// G: Residual state.
+	//
+	// S: Variance of the residual state.
+	//
+	// C: Variance of the jump sequence.
+	//
+	// NSAMPS: Length of the binary event sequence.
+	//
+	// D: Segment density.
+	//
+	// Input/output parameters:
+	// Q: Binary event sequence.  This sequence is updated by SingleMostLikelihoodReplacement.
+	//
+	// Output parameters:
+	// CONV: Convergence flag.
+	//		CONV = 0 => No convergence.
+	//		CONV = 1 => SingleMostLikelihoodReplacement convergence.
+	//
+	// IER: Return error code.
+	//		IER = 0 => No error.
+	//		IER = 1 => logarithm argument became zero at sample number IER.
+
+	// Input initialization.
+	IER		= 0;
+	CONV	= 0;
+
+	// Local variable initialization.
+	double LNHOLD	= log(D / (1.0-D));
+	int INDKNT		= 0;
+	int INDSTR		= 0;
+	double GLOBAL	= 0;
+
+	// Calculate log-likelihood ratios.
+	for (int i = 0; i < NSAMPS; i++)
+	{
+		double DHOLD	= 1.0 - 2.0 * Q[i];
+		double LOGARG	= 1.0 + C * DHOLD * S[i];
+
+		if (LOGARG <= 0)
+		{
+			IER = i;
+			return;
+		}
+		
+		double HOLD3 = -0.5 * log(LOGARG);
+		double HOLD1 = C * G[i] * G[i] * DHOLD / (2.0*LOGARG);
+		double STORE = HOLD1 + DHOLD * LNHOLD + HOLD3;
+		if (STORE > 0)
+		{
+			INDKNT++;
+			if (STORE > GLOBAL)
+			{
+				GLOBAL = STORE;
+				INDSTR = i;
+			}
+		}
+	}
+
+	if (INDKNT < 1)
+	{
+		// In case of convergence, return.
+		CONV = true;
+	}
+	else
+	{
+		// Reset event.
+		Q[INDSTR] = !Q[INDSTR];
+	}
+}
+
+// Original function name: THOLD
+void Threshold(double JMPSEQ[], double C, double F, int NSAMPS, int Q[], double& D)
+{
+	// Function:
+	// Threshold procedure to estimate an initial event sequence.
+	//
+	// Input parameters:
+	// JMPSEQ: Jump sequence estimate obtained with the event sequence Q set to unity for all values.
+	//
+	// C: Variance of the jump sequence.
+	//
+	// F: Segmentation threshold index.
+	//
+	// NSAMPS: Length of the array JMPSEQ.
+	//
+	// Output parameters:
+	// Q: Estimated binary event sequence.
+	//
+	// D: Estimated segment density.
+
+	D = 0.0;
+
+	for (int i = 0; i < NSAMPS; i++)
+	{
+ 		if (F*C <= JMPSEQ[i]*JMPSEQ[i])
+		{
+			Q[i]	= 1;
+			D		= D + 1.0;
+		}
+		else
+		{
+			Q[i] = 0;
+		}
+	}
+
+	D	= D / (double)NSAMPS;
+}
+
+// Original function name: MOVAVG
+void MovingAverage(double ARR1[], int NSAMPS, int ORDER, double ARR2[])
+{
+	// Function:
+	// Centered moving average.
+	//
+	// Input parameters:
+	// ARR1: Input data array to be averaged.
+	//
+	// NSAMPS: Length of the input data array (ARR1).
+	//
+	// ORDER: One sided length of the moving average window.
+	//
+	// Output parameters:
+	// ARR2: Averaged data array.
+
+	if (ORDER >= NSAMPS)
+	{
+		// Auto correct.
+		ORDER = NSAMPS-2;
+	}
+
+	ARR2[0]			= ARR1[0];
+	ARR2[NSAMPS-1]	= ARR1[NSAMPS-1];
+
+	// Average build and drop (beginning and end of average array).
+	double SUM  = ARR1[0];
+	double SUM1 = ARR1[NSAMPS-1];
+	
+	int jfront = -1;
+	int jback = NSAMPS;
+
+	for (int i = 1; i < ORDER+1; i++)
+	{
+		// Building by 2 because this is a "central" moving average.
+		jfront = jfront + 2;
+		jback = jback - 2;
+		SUM = SUM + ARR1[jfront] + ARR1[jfront+1];
+		SUM1 = SUM1 + ARR1[jback] + ARR1[jback-1];
+		ARR2[i] = SUM / ((double)jfront + 2);
+		ARR2[NSAMPS-1-i] = SUM1 / ((double)jfront + 2);
+	}
+
+	// Average stable.
+	jfront	= jfront + 2;
+	jback	= 0;
+
+	for (int i = ORDER+1; i < NSAMPS-ORDER; i++)
+	{
+		SUM = SUM + ARR1[jfront] - ARR1[jback];
+		ARR2[i] = SUM / ((double)ORDER * 2 + 1);
+		jfront++;
+		jback++;
+	}
+}
+
+// Original function name: KALMAN
+void KalmanFilter(double LOG[], int Q[], double C, double R[], int NSAMPS, double GAIN[], double ZTLT[], double ETA[], double STATE[])
+{
+	// Function:
+	// One dimensional KalmanFilter filter.
+	//
+	// Input parameters:
+	// LOG: Input discretized well log.
+	//
+	// Q: Binary event sequence.
+	//
+	// C: Variance of the jump sequence.
+	//
+	// NSAMPS: Length of the input well log.
+	//
+	// Output parameters:
+	// GAIN: KalmanFilter gain array.
+	//
+	// ZTLT: Innovation sequence.
+	//
+	// ETA: Variance of the innovation sequence.
+	//
+	// STATE: Estimated state values (filtered log).
+
+	// Init state and its variance.
+	double VAR = 0.0;
+
+	if (Q[0])
+	{
+		VAR = C;
+	}
+
+	ZTLT[0]		= 0.0;
+	ETA[0]		= VAR + R[0];
+	GAIN[0]		= VAR / ETA[0];
+	STATE[0]	= LOG[0] + GAIN[0] * ZTLT[0];
+	VAR			= (1.0 - GAIN[0]) * VAR;
+
+	// Estimate state and its variance (one dim KalmanFilter filter).
+	for (int i = 1; i < NSAMPS; i++)
+	{
+		if (Q[i])
+		{
+			VAR = VAR + C;
+		}
+
+		ZTLT[i]		= LOG[i] - STATE[i-1];
+		ETA[i]		= VAR + R[i];
+		GAIN[i]		= VAR / ETA[i];
+		STATE[i]	= STATE[i-1] + GAIN[i] * ZTLT[i];
+		VAR			= (1.0 - GAIN[i]) * VAR;
+	}
+}
+
+// Original function name: FIOS
+void FixedIntervalOptimalSmoother(int Q[], int NSAMPS, double C, double ARR1[], double ARR2[], double ARR3[])
+{
+	// Function:
+	// Fixed interval optimal smoother to estimate the jump sequence, residual state and its variance.
+	//
+	// Input parameters:
+	// Q: Binary event sequence.
+	//
+	// NSAMPS: Length of the binary event sequence Q.
+	//
+	// C: Variance of the jump sequence.
+	//
+	// Input/output parameters:
+	// ARR1: Variance of the innovation sequence.  On return it contains the product Q*R.
+	//
+	// ARR2: Innovation sequence.  On return it contains S (variance of residual state).
+	//
+	// ARR3: KalmanFilter gain array.  On return it contains G (residual state).
+
+	int lastindex = NSAMPS - 1;
+
+	ARR3[lastindex] = ARR2[lastindex] / ARR1[lastindex];
+	ARR2[lastindex] = 1.0 / ARR1[lastindex];
+	ARR1[lastindex] = C * Q[lastindex] * ARR3[lastindex];
+
+	for (int i = lastindex-1; i > -1; i--)
+	{
+		double TEMP = 1.0 - ARR3[i];
+		ARR3[i] = TEMP * ARR3[i+1] + ARR2[i] / ARR1[i];
+		ARR2[i] = TEMP * TEMP * ARR2[i+1] + 1.0 / ARR1[i];
+		ARR1[i] = C * Q[i] * ARR3[i];
+	}
+}
+
+// Original function name: DATAVG
+void AverageArraySegments(double ARR[], int Q[], int NSAMPS, double AVGOUT[])
+{
+	// Function:
+	// Data array to be averaged within segments implied by an event sequence Q.
+	//
+	// Input parameters:
+	// ARR: Input data array to be averaged.
+	//
+	// Q: Binary event sequence.
+	//
+	// NSAMPS: Length of the input data array (ARR).
+	//
+	// Output parameters:
+	// AVGOUT: Output data averaged within each segment implied by the event sequence Q.
+
+	bool endofarray	= false;
+	int SEGSTR		= 0;
+
+	while (!endofarray)
+	{
+		int SEGEND;
+		int SEGLEN;
+		double SEGAVG;
+
+		GetSegment(ARR, Q, NSAMPS, SEGSTR, SEGEND, SEGLEN, SEGAVG, endofarray);
+
+		for (int i = SEGSTR; i <= SEGEND; i++)
+		{
+			AVGOUT[i] = SEGAVG;
+		}
+
+		SEGSTR	= SEGEND + 1;
+	}
+}
+
+// Original function name: UPDNSE
+void DeglitchAndEstimateNoiseVariance(double LOG[], int Q[], int NSAMPS, int RMODE, double WORK1[], double R[])
+{
+	// Function:
+	// Deglitch and re-estimate noise variance.
+	//
+	// Input parameters:
+	// LOG: Input discretized well log to be used for updating noise variance R.
+	//
+	// Q: Binary event sequence.
+	//
+	// NSAMPS: Length of the input well log.
+	//
+	// RMODE: Noise variance estimate option.
+	//		RMODE = 0 ==> Point estimate of noise variance.
+	//		RMODE = 1 ==> Noise estimates smoothed within segments.
+	//
+	// Output parameters:
+	// R: Estimated noise variance.
+
+	// Average the log within each segment implied by Q.
+	AverageArraySegments(LOG, Q, NSAMPS, WORK1);
+
+	// Calculate the noise variance R.
+	for (int i = 0; i < NSAMPS; i++)
+	{
+		WORK1[i] = (LOG[i] - WORK1[i]) * (LOG[i] - WORK1[i]);
+		
+		if (WORK1[i] <= 0.0)
+		{
+			WORK1[i] = 1.0;
+		}
+	}
+
+	// Point estimate.
+	if (RMODE == 0)
+	{
+		for (int i = 0; i < NSAMPS; i++)
+		{
+			R[i] = WORK1[i];
+		}
+	}
+	else
+	{
+		// Smooth the noise variance R within each segment.
+		int SEGSTR = 0;
+		bool endofarray = false;
+
+		while (!endofarray)
+		{
+			// Outputs from call to "GetSegment".
+			int SEGEND;
+			int SEGLEN;
+			double SEGAVG;
+
+			GetSegment(LOG, Q, NSAMPS, SEGSTR, SEGEND, SEGLEN, SEGAVG, endofarray);
+
+			int IOR = SEGLEN/3;
+			if (IOR > 0)
+			{
+				MovingAverage(&(WORK1[SEGSTR]), SEGLEN, IOR, &(R[SEGSTR]));
+			}
+			else
+			{
+				for (int i = SEGSTR; i <= SEGEND; i++)
+				{
+					R[i] = WORK1[i];
+				}
+			}
+		
+			SEGSTR = SEGEND + 1;
+		}
+	}
+}
+
+// Original function name: GETSEG
+void GetSegment(double LOG[], int Q[], int NSAMPS, int SEGSTR, int& SEGEND, int& SEGLEN, double& SEGAVG, bool& endofarray)
+{
+	// Function:
+	// Identifies a segment within a given event sequence.
+	// A segment is defined by the sequence 1,0,0,...,0,1.
+	//
+	// Input parameters:
+	// LOG: Data array for which the averages are to be computed.
+	//
+	// Q: Binary event sequence which identifies the segments in the input array log.
+	//
+	// NSAMPS: Length of the input array log.
+	//
+	// SEGSTR: Sample number where the segment boundary starts.
+	//
+	// Output parameters:
+	// SEGEND: Sample number where the segment boundary ends.
+	//
+	// SEGLEN: Length of the segment.
+	//
+	// SEGAVG: Average value of the input data array log over the segment.
+	//
+	// endofarray: End of data indicator.
+	//		true: End of array reached.
+	//		false: Not at end of the array.
+
+	endofarray	= false;
+	SEGEND		= SEGSTR;
+	SEGAVG		= 0;
+
+	do
+	{
+		SEGAVG = SEGAVG + LOG[SEGEND];
+		SEGEND = SEGEND + 1;
+	}
+	while (!Q[SEGEND] && SEGEND < NSAMPS);
+
+	if (SEGEND == NSAMPS)
+	{
+		// We hit the end of the array without finding an event indicator (a "1" in the "Q" array).
+		endofarray = true;
+	}
+
+	// In the case were we found a "1" in the "Q" array the end of the segment is the previous
+	// index before the event ("1").  If we hit the end of the array first, SEGEND == NSAMPS which
+	// is past the end of the array so it needs to be de-incremented.
+	SEGEND--;
+
+	SEGLEN = SEGEND - SEGSTR + 1;
+	SEGAVG = SEGAVG / SEGLEN;
+}
+
+// Original function name: DEGLCH
+void Deglitch(int NSAMPS, int Q[])
+{
+	// Function:
+	// Deglitches all the spiky zones in the event sequence Q.
+	//
+	// Input parameters:
+	// NSAMPS: Length of the array Q.
+	//
+	// Input/output parameters:
+	// Q: Binary event sequence to be deglitched.  On return this contains the updated event
+	//		sequence.  It is of length "NSAMPS."
+
+	int SEGSTR		= 0;
+	bool endofarray = false;
+
+	do
+	{
+		int SEGEND;
+		GetSpikeyZone(Q, NSAMPS, SEGSTR, SEGEND, endofarray);
+
+		if (SEGSTR == SEGEND)
+		{
+			SEGSTR++;
+		}
+		else
+		{
+			if (SEGEND == SEGSTR+1)
+			{
+				Q[SEGSTR] = 0;
+			}
+			else
+			{
+				for (int i = SEGSTR+1; i < SEGEND; i++)
+				{
+					Q[i] = 0;
+				}
+			}
+			SEGSTR = SEGEND + 1;
+		}
+	}
+	while (!endofarray);
+}
+
+// Original function name: GETSPK
+void GetSpikeyZone(int Q[], int NSAMPS, int SEGSTR, int& SEGEND, bool& endofarray)
+{
+	// Function:
+	// Identifies a zone of spikes.  A spiky zone is defined by 0,1,1,...,1,0.
+	//
+	// Input parameters:
+	// Q: Binary event sequence in which the zone is to be identified.
+	//
+	// NSAMPS: Length of the array Q.
+	//
+	// SEGSTR: Sample number where the spiky zone starts.
+	//
+	// Output parameters:
+	// SEGEND: Sample number where the zone ends.
+	//
+	// endofarray: End of data indicator.
+	//		true: End of array reached.
+	//		false: Not at end of the array.
+
+	SEGEND = SEGSTR;
+	if (!Q[SEGEND])
+	{
+		// Modified from original paper.  The "if" statement below was not part of the original algorithm.
+		// It seems there can be a case where Q[i] < 0.5 for SEGEND = NSAMPS that causes us to miss flagging the end
+		// of the array.  Do a check here to ensure we don't overrun the end of the array and over write memory we should
+		// not over write.
+		if (SEGEND >= NSAMPS)
+		{
+			endofarray	= true;
+			SEGEND		= NSAMPS - 1;
+		}
+
+		return;
+	}
+
+	do
+	{
+		SEGEND++;
+	}
+	while (Q[SEGEND] && (SEGEND < NSAMPS));
+
+	if (SEGEND >= NSAMPS)
+	{
+		endofarray = true;
+	}
+
+	SEGEND--;
+}
+
+// Original function name: UPDDEN
+void EstimateEventDensity(int Q[], int NSAMPS, double& D, int& NQ)
+{
+	// Function:
+	// Estimates the event density for a given event sequence.
+	//
+	// Input parameters:
+	// Q: Binary event sequence for which the event density is to be estimated.
+	//
+	// NSAMPS: Length of the array Q.
+	//
+	// Output parameters:
+	// D: Estimated segment density.
+	//
+	// NQ: Number of binary events found (number of "1"s in Q).
+
+	D = 0;
+	for (int i = 0; i < NSAMPS; i++)
+	{
+		D = D + Q[i];
+	}
+
+	// Store the number of events found, the calculate the event density.
+	NQ	= (int)D;
+	D = D / (double)NSAMPS;
+}
+
+// Original function name: ESTSIG
+void EstimateVarianceOfJumpSequence(double LOG[], int NSAMPS, double WORK1[], double& C)
+{
+	// Function:
+	// Estimates initially C, the variance of the jump sequence as the variance of unit-step
+	// finite difference of input smoothed log.
+	//
+	// Input parameters:
+	// LOG: Smoothed well log.
+	//
+	// NSAMPS: Length of the array log.
+	//
+	// Output parameters:
+	// C: Estimated variance of the jump sequence.
+
+	// Estimate jump sequence as the unit-step finite difference of input log.
+	WORK1[0] = 0;
+	for (int i = 1; i < NSAMPS; i++)
+	{
+		WORK1[i] = LOG[i] - LOG[i-1];
+	}
+
+	// Calculate the variance of the differ log (consider non zero values).
+	double MEAN;
+	CalculateMeanAndVariance(WORK1, NSAMPS, 1, MEAN, C);
+}
+
+// Original function name: VARNCE
+void CalculateMeanAndVariance(double ARRAY[], int NSAMPS, int MODE, double& MEAN, double& VAR)
+{
+	// Function:
+	// Calculates mean and variance.
+	//
+	// Input parameters:
+	// ARRAY: Input data array for which the mean and variance is to be calculated.
+	//
+	// NSAMPS: Length of the input array.
+	//
+	// MODE: Option to include zero values for calculating mean and variance.
+	//		MODE == 0 = Consider all values.
+	//		MODE == 1 = Consider only non zero values.
+	//
+	// Output parameters:
+	// MEAN: Calculated mean of the given data.
+	//
+	// VAR: Calculated variance of the given data.
+
+	int NZEKNT	= 0;
+	MEAN		= 0;
+	VAR			= 0;
+
+	// Calculate sum and sum of squares.
+	for (int i = 0; i < NSAMPS; i++)
+	{
+
+		if (ARRAY[i] != 0)
+		{
+			NZEKNT++;
+			MEAN	= MEAN + ARRAY[i];
+			VAR		= VAR + ARRAY[i]*ARRAY[i];
+		}
+	}
+
+	// Calculate mean and variance.
+	if (MODE == 0)
+	{
+		MEAN = MEAN / (double)NSAMPS;
+		VAR = VAR / (double)NSAMPS - MEAN*MEAN;
+	}
+	else
+	{
+		MEAN = MEAN / (double)NZEKNT;
+		VAR = VAR / (double)NZEKNT - MEAN*MEAN;
+	}
+}

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.

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/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
+}

SegmentSignalPy-0.1.2.dist-info/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2021-2024 Lance A. Endres
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

SegmentSignalPy-0.1.2.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: SegmentSignalPy
+Version: 0.1.2
+Summary: Signal segmentation algorithm by S. Radhakrishnan, et al. This is a Python interface for the C++ algorithm.
+License: Copyright (c) 2021-2024 Lance A. Endres
+        
+        Permission is hereby granted, free of charge, to any person obtaining
+        a copy of this software and associated documentation files (the
+        "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish,
+        distribute, sublicense, and/or sell copies of the Software, and to
+        permit persons to whom the Software is furnished to do so, subject to
+        the following conditions:
+        
+        The above copyright notice and this permission notice shall be
+        included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+        LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+        OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+        WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: homepage, https://github.com/lendres/Segment-Signals
+Requires-Python: >=3.11.0
+Description-Content-Type: text/markdown
+License-File: License.txt
+
+# Segment Signals
+A signal segmentation algorithm.
+
+## Compiling
+The Python Extension library requires the knowledge of your local Python. See the *Read Me.txt* file in that directory for more information.

SegmentSignalPy-0.1.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+SegmentSignalPy.cp312-win_amd64.pyd,sha256=D5rwZKT53ySZoyyQWZYK8-Dm78ow_SsY-2yOLgsUndg,174592
+CPP Static Library/SegmentSignal.cpp,sha256=XGf7SdVFowKUA1XTUV3w3vPlVMmObtCqfpLlgtpqhRY,7486
+CPP Static Library/SegmentSignalFunctions.cpp,sha256=nvjUUJrsMl8Bm3EfHlmtepXPw8xHL_4gen54zmbndXE,20026
+CPP Static Library/SegmentationResults.cpp,sha256=TfETLOiGQgIQhEcCUqBjSvT4gejc0ls24hrX8OL8k1s,1812
+Python Extension/SegmentationResultsPy.cpp,sha256=KZXoTBjRYUfwmM_ObRcycDKB4hciLWxElIIJ5WJze4k,4112
+Python Extension/module.cpp,sha256=7vzVS5YOBfL2S21BOwMKiR6z8GDM1hT9wYWvCTJjPv0,6726
+SegmentSignalPy-0.1.2.dist-info/License.txt,sha256=P9Td1RUysGlkcCTbn7PzBHFee-iPtG0zuLzEuVOB_j8,1084
+SegmentSignalPy-0.1.2.dist-info/METADATA,sha256=jAHSBw0IVHV1mnq29CmYR3TkNyy9wA-4ysRn_hb7mgI,1810
+SegmentSignalPy-0.1.2.dist-info/WHEEL,sha256=a7uKbwsC-jaWILXrHBfbCoELaoc3NJo_uE06BJFfWa4,101
+SegmentSignalPy-0.1.2.dist-info/top_level.txt,sha256=Gg1JGAQCkw2ZivMSVOurzJ3yu03GWXQVKWOrCRc_oA0,135
+SegmentSignalPy-0.1.2.dist-info/RECORD,,

SegmentSignalPy-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (71.1.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64
+

SegmentSignalPy-0.1.2.dist-info/top_level.txt

@@ -0,0 +1,9 @@
+C DLL
+C Sharp Unit Tests
+C Sharp Wrapper
+CPP Static Library
+CPP Unit Tests
+Matlab Extension
+Python Extension
+SegmentSignalPy
+Test Data