SegmentSignalPy 0.1.2__tar.gz → 0.1.3__tar.gz

segmentsignalpy-0.1.3/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include src *.h

segmentsignalpy-0.1.3/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: SegmentSignalPy
+Version: 0.1.3
+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
+
+# Segment Signals
+A signal segmentation algorithm.
+
+## Introduction
+This library implements the algorithm found in:
+[_Segmentation of well logs by maximum likelihood estimation: the algorithm and FORTRAN-77 implementation_](https://www.sciencedirect.com/science/article/pii/0098300491900237) by S.Radhakrishnan, G.Srikanth, and C.H.Mehta
+
+The original algorithm was written in Fortran.  This version converts it to C++ and C#.  In addition, the following changes have been made:
+- Converted the binary event array (Q) from double to int.  Likely, the original was a double to keep all options as floats and prevent accidental round off.  C/C++ automatically perform calculations as doubles when any of the parameters is a double.  The binary event sequence is, of course, meant to be binary, so conversion to int is logical.  This also meant a few lines could be simplified (such as comparisons).  E.g. you could directly test "if (Q[i])" rather than requiring the inequality.
+- Removed a bug from the GETSPK/GetSpikeyZone function.  The fix prevents over running the end of an array.
+- Addition of `FindSignificantZones` to allow simple filtering (removal) of small zones.
+
+## Organization
+A high-level view of the organization is as follows.
+
+- CPP Static Library
+	- SegmentSignalFunctions.
+		- **It is suggested not to use these directly, but to use the class `SegmentSignal` instead.**
+		These files implement the original algorithm in C++.  The function names have changed to something more readable.  The original function names can be found in the comments in
+		the .cpp file.  The functions have otherwise been directly converted from Fortran and should be easily comparable to those in the source paper.
+	- SegmentSignal.*
+		- A class interface to the functions that makes use of the algorithm easier.
+	- SegmentationResults.*
+		- Small class to return results of the algorithm.
+	- NoiseVarianceEstimateMethod.h
+		- Enumeration for the noise variance estimation method.
+
+- C DLL
+	- DLL wrapper around the main SegmentSignal function.  The DLL exposes a C function for calling.
+
+- C Sharp DLL Wrapper
+	- C# interface to the DLL.  Classes mirror those in C++.
+
+-  Unit Tests
+	- Testing projects.  Also provides examples.  See the "LogSeparateTest" functions for a basic example.
+
+- Python Extensions
+	- Builds a library for use with Python.  See the `src/Python Extensions/Read Me.txt` file in that project for more information.
+
+## Compiling
+The Python Extension library requires knowledge of your local Python. See the `src/Python Extensions/Read Me.txt` file in that directory for more information.

segmentsignalpy-0.1.3/README.md

@@ -0,0 +1,41 @@
+# Segment Signals
+A signal segmentation algorithm.
+
+## Introduction
+This library implements the algorithm found in:
+[_Segmentation of well logs by maximum likelihood estimation: the algorithm and FORTRAN-77 implementation_](https://www.sciencedirect.com/science/article/pii/0098300491900237) by S.Radhakrishnan, G.Srikanth, and C.H.Mehta
+
+The original algorithm was written in Fortran.  This version converts it to C++ and C#.  In addition, the following changes have been made:
+- Converted the binary event array (Q) from double to int.  Likely, the original was a double to keep all options as floats and prevent accidental round off.  C/C++ automatically perform calculations as doubles when any of the parameters is a double.  The binary event sequence is, of course, meant to be binary, so conversion to int is logical.  This also meant a few lines could be simplified (such as comparisons).  E.g. you could directly test "if (Q[i])" rather than requiring the inequality.
+- Removed a bug from the GETSPK/GetSpikeyZone function.  The fix prevents over running the end of an array.
+- Addition of `FindSignificantZones` to allow simple filtering (removal) of small zones.
+
+## Organization
+A high-level view of the organization is as follows.
+
+- CPP Static Library
+	- SegmentSignalFunctions.
+		- **It is suggested not to use these directly, but to use the class `SegmentSignal` instead.**
+		These files implement the original algorithm in C++.  The function names have changed to something more readable.  The original function names can be found in the comments in
+		the .cpp file.  The functions have otherwise been directly converted from Fortran and should be easily comparable to those in the source paper.
+	- SegmentSignal.*
+		- A class interface to the functions that makes use of the algorithm easier.
+	- SegmentationResults.*
+		- Small class to return results of the algorithm.
+	- NoiseVarianceEstimateMethod.h
+		- Enumeration for the noise variance estimation method.
+
+- C DLL
+	- DLL wrapper around the main SegmentSignal function.  The DLL exposes a C function for calling.
+
+- C Sharp DLL Wrapper
+	- C# interface to the DLL.  Classes mirror those in C++.
+
+-  Unit Tests
+	- Testing projects.  Also provides examples.  See the "LogSeparateTest" functions for a basic example.
+
+- Python Extensions
+	- Builds a library for use with Python.  See the `src/Python Extensions/Read Me.txt` file in that project for more information.
+
+## Compiling
+The Python Extension library requires knowledge of your local Python. See the `src/Python Extensions/Read Me.txt` file in that directory for more information.

{segmentsignalpy-0.1.2 → segmentsignalpy-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "SegmentSignalPy"
-version = "0.1.2"
+version = "0.1.3"
 requires-python = ">=3.11.0"
 description = "Signal segmentation algorithm by S. Radhakrishnan, et al. This is a Python interface for the C++ algorithm."
 readme = "README.md"

segmentsignalpy-0.1.3/src/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);
+	}
+}

segmentsignalpy-0.1.3/src/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

segmentsignalpy-0.1.3/src/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

segmentsignalpy-0.1.3/src/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

segmentsignalpy-0.1.3/src/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

segmentsignalpy-0.1.3/src/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

segmentsignalpy-0.1.3/src/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

segmentsignalpy-0.1.3/src/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>

segmentsignalpy-0.1.3/src/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

segmentsignalpy-0.1.3/src/Python Extension/setup.py

@@ -0,0 +1,26 @@
+import os
+from   setuptools                     import setup
+from   setuptools                     import Extension
+from   pybind11                       import get_include
+
+
+sourceDirectory = os.path.join("src", "CPP Static Library")
+pythonDirectory = os.path.join("src", "Python Extension")
+
+setup(
+    ext_modules=[
+        Extension(
+            name="SegmentSignalPy",
+            sources=[
+                os.path.join(pythonDirectory, file)
+                for file in ["module.cpp", "SegmentationResultsPy.cpp"]
+            ] + [
+                os.path.join(sourceDirectory, file)
+                for file in ["SegmentSignalFunctions.cpp", "SegmentationResults.cpp", "SegmentSignal.cpp"]
+            ],
+            include_dirs=[get_include(), sourceDirectory],
+            language="c++",
+            extra_compile_args=[]
+        )
+    ]
+)

segmentsignalpy-0.1.3/src/SegmentSignalPy.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: SegmentSignalPy
+Version: 0.1.3
+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
+
+# Segment Signals
+A signal segmentation algorithm.
+
+## Introduction
+This library implements the algorithm found in:
+[_Segmentation of well logs by maximum likelihood estimation: the algorithm and FORTRAN-77 implementation_](https://www.sciencedirect.com/science/article/pii/0098300491900237) by S.Radhakrishnan, G.Srikanth, and C.H.Mehta
+
+The original algorithm was written in Fortran.  This version converts it to C++ and C#.  In addition, the following changes have been made:
+- Converted the binary event array (Q) from double to int.  Likely, the original was a double to keep all options as floats and prevent accidental round off.  C/C++ automatically perform calculations as doubles when any of the parameters is a double.  The binary event sequence is, of course, meant to be binary, so conversion to int is logical.  This also meant a few lines could be simplified (such as comparisons).  E.g. you could directly test "if (Q[i])" rather than requiring the inequality.
+- Removed a bug from the GETSPK/GetSpikeyZone function.  The fix prevents over running the end of an array.
+- Addition of `FindSignificantZones` to allow simple filtering (removal) of small zones.
+
+## Organization
+A high-level view of the organization is as follows.
+
+- CPP Static Library
+	- SegmentSignalFunctions.
+		- **It is suggested not to use these directly, but to use the class `SegmentSignal` instead.**
+		These files implement the original algorithm in C++.  The function names have changed to something more readable.  The original function names can be found in the comments in
+		the .cpp file.  The functions have otherwise been directly converted from Fortran and should be easily comparable to those in the source paper.
+	- SegmentSignal.*
+		- A class interface to the functions that makes use of the algorithm easier.
+	- SegmentationResults.*
+		- Small class to return results of the algorithm.
+	- NoiseVarianceEstimateMethod.h
+		- Enumeration for the noise variance estimation method.
+
+- C DLL
+	- DLL wrapper around the main SegmentSignal function.  The DLL exposes a C function for calling.
+
+- C Sharp DLL Wrapper
+	- C# interface to the DLL.  Classes mirror those in C++.
+
+-  Unit Tests
+	- Testing projects.  Also provides examples.  See the "LogSeparateTest" functions for a basic example.
+
+- Python Extensions
+	- Builds a library for use with Python.  See the `src/Python Extensions/Read Me.txt` file in that project for more information.
+
+## Compiling
+The Python Extension library requires knowledge of your local Python. See the `src/Python Extensions/Read Me.txt` file in that directory for more information.

segmentsignalpy-0.1.3/src/SegmentSignalPy.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+License.txt
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+src/C DLL/DLLExport.h
+src/CPP Static Library/NoiseVarianceEstimateMethod.h
+src/CPP Static Library/SegmentSignal.cpp
+src/CPP Static Library/SegmentSignal.h
+src/CPP Static Library/SegmentSignalFunctions.cpp
+src/CPP Static Library/SegmentSignalFunctions.h
+src/CPP Static Library/SegmentationResults.cpp
+src/CPP Static Library/SegmentationResults.h
+src/CPP Unit Tests/InputDataEnum.h
+src/CPP Unit Tests/stdafx.h
+src/CPP Unit Tests/targetver.h
+src/Python Extension/SegmentationResultsPy.cpp
+src/Python Extension/SegmentationResultsPy.h
+src/Python Extension/module.cpp
+src/Python Extension/setup.py
+src/SegmentSignalPy.egg-info/PKG-INFO
+src/SegmentSignalPy.egg-info/SOURCES.txt
+src/SegmentSignalPy.egg-info/dependency_links.txt
+src/SegmentSignalPy.egg-info/top_level.txt

segmentsignalpy-0.1.2/PKG-INFO

@@ -1,34 +0,0 @@
-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
-
-# 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/README.md

@@ -1,5 +0,0 @@
-# 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/src/SegmentSignalPy.egg-info/PKG-INFO

@@ -1,34 +0,0 @@
-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
-
-# 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/src/SegmentSignalPy.egg-info/SOURCES.txt

@@ -1,13 +0,0 @@
-License.txt
-README.md
-pyproject.toml
-setup.py
-src/CPP Static Library/SegmentSignal.cpp
-src/CPP Static Library/SegmentSignalFunctions.cpp
-src/CPP Static Library/SegmentationResults.cpp
-src/Python Extension/SegmentationResultsPy.cpp
-src/Python Extension/module.cpp
-src/SegmentSignalPy.egg-info/PKG-INFO
-src/SegmentSignalPy.egg-info/SOURCES.txt
-src/SegmentSignalPy.egg-info/dependency_links.txt
-src/SegmentSignalPy.egg-info/top_level.txt