drinkussions(Baban and Saanjoo): wavs to mids

namespace SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_TESTED_ON_380000_WAV_FILES_GETTING_VERTICAL_SPECTRUMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS__ANALYSISWaveform___WITH_TRANSPARENT_RECTANGLES_OF_TRACING_PAPER_STACKS_BITMAPS_CSV_REPORTS

{

public class WavMetadata

{

public int SampleRate;

public int BitsPerSample;

public int Channels;

}//public class WavMetadata

public class CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

{

//CrestTroughAnalyzer___WITH_TRANSPARENT_RECTANGLES_OF_TRACING_PAPER_STACKS_BITMAPS_CSV_REPORTS.

public static double PUBLIC_STATIC_DOUBLE_MIN_WIDTH_MIKROSEC_FOUND_IN_CRESTS = +600000000;

public static double PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_CRESTS = -600000000;

public static double PUBLIC_STATIC_DOUBLE_MIN_WIDTH_MIKROSEC_FOUND_IN_TROUGHS = +600000000;

public static double PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_TROUGHS = -600000000;

public static double PUBLIC_STATIC_DOUBLE_MIN_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS = +600000000;

public static double PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS = -600000000;

public static double PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUND_IN_CRESTS = -600000000;

public static double PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUND_IN_TROUGHS = -600000000;

public static double PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUNDOVERALL_IN_CRESTS_AND_TROUGHS = -600000000;

//CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

public static int PUBLIC_STATIC_INT___THE_SAMPLES_PER_sECOND_FOUND_WHILE_READING = 8000;

//CALLING CONVENTIONS

public static double PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES = 0;

public static double PUBLIC_STATIC_DOUBLE_AVERAGE_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES = 0;

public static int PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE = 0;

//we populate these at CALL_THIS_BEFORE_GENERATING___RANKED_WAV_FILES___ExportDxf_With_CREST_TROUGH_COUNTER_AS_Y_VALUES___SAAN_STYLES_SINGLE_OUTER_GRAPH_SAANS_NORMALIZED_SCALED_TO_MAX_WIDTH_CG_X_DATABoxesAndText

public static float[] PUBLIC_STATIC_FLOAT_ARRAY____RAW_SAMPLES_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES = null;

public static float[] PUBLIC_STATIC_FLOAT_ARRAY____RECONSTRUCTED_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES = null;

//SANJOY NATH HAS SEEN THAT IN 380000 WAV FILES ANALYSIS THAT NON DUPLICATE X OF CG ARE <=600 IN COUNTS OF NON DUPLICATE X OF CG FOUND THAT IS NOT MORE THAN

//CALLING CONVENTION IS LIKE THIS

//////CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

//////.PUBLIC_STATIC_ARRAY_OF_LISTS_OF_CrestTroughObject___WITH_SORTED_SMALLEST_TO_LARGEST_NON_DUPLICATE_SAAN_STYLES_SCALED_NORMALIZED_SCALED_X___0_TO_600_UNIQUE_RANKS_OF_SORTED_NORMALIZED_X_OF_CG

public static List<CrestTroughObject>[]

PUBLIC_STATIC_ARRAY_OF_LISTS_OF_CrestTroughObject___WITH_SORTED_SMALLEST_TO_LARGEST_NON_DUPLICATE_SAAN_STYLES_SCALED_NORMALIZED_SCALED_X___0_TO_600_UNIQUE_RANKS_OF_SORTED_NORMALIZED_X_OF_CG

new List<CrestTroughObject>[600];

//WE WILL GENERATE SEPERATE WAV FILES (WE PRESERVE THE ORIGINAL AMPLITUDES SAMPLES JUST TO CROSS CHECK THE RE GENERATED WAV FILES) WITH CG_X_RANKED DIFFERENT RANKED WAV FILES TO SEE HOW THE FREQUENCY OF CREST AABB TROUGH AABB BEHAVES WHILE LISTENING THE FINAL FILTERED WAV FILES

// THESE RANKING OR PRESERVED SAMPLES ARE NOT PART OF THE SANJOY NATH'S NEW WAVE THEORY BUT IT IS JUST TO CROSS VERIFY THE THEORY TO CHECK THE CLAIMS ARE PROPER OR NOT

public static WavMetadata ReadMetadata(string path)

{

WavMetadata meta = new WavMetadata();

using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

{

br.ReadBytes(12); // RIFF header

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSize = br.ReadInt32();

if (chunkID == "fmt ")

{

br.ReadInt16(); // audio format

meta.Channels = br.ReadInt16();

meta.SampleRate = br.ReadInt32();

br.ReadInt32(); // byte rate

br.ReadInt16(); // block align

meta.BitsPerSample = br.ReadInt16();

if (chunkSize > 16)

br.ReadBytes(chunkSize - 16); // skip extra

break;

}

else

{

br.BaseStream.Seek(chunkSize, SeekOrigin.Current);

}//end of else of if (chunkID == "fmt ")

}//while (br.BaseStream.Position < br.BaseStream.Length)

}// using (BinaryReader br = new BinaryReader(File.OpenRead(path)))

///////public static int PUBLIC_STATIC_INT___THE_SAMPLES_PER_sECOND_FOUND_WHILE_READING = 8000;

CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

.PUBLIC_STATIC_INT___THE_SAMPLES_PER_sECOND_FOUND_WHILE_READING

= meta.SampleRate;

return meta;

}//public static WavMetadata ReadMetadata(string path)

//////public static void GenerateRankedSpectralWavFiles(

////// List<CrestTroughObject> allCrestTroughObjects,

////// int totalSamples,

////// int sampleRate,

////// string outputFolder)

////// {

////// // Sort by scaled CG_X to identify vertical spectral alignment

////// var rankedGroups = allCrestTroughObjects

////// .GroupBy(obj => Math.Round(obj.PUBLIC_DOUBLE_NON_DUPLICATE_CG_X_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTSScaled_CG_X, 6)) // group by X of CG

////// .OrderBy(g => g.Key)

////// .Select((group, rankIndex) => new { Rank = rankIndex + 1, Objects = group.ToList() })

////// .ToList();

////// foreach (var group in rankedGroups)

////// {

////// short[] outputSamples = new short[totalSamples];

////// foreach (var obj in group.Objects)

////// {

////// for (int i = obj.StartSampleIndex; i <= obj.EndSampleIndex; i++)

////// {

////// // Clip to avoid overflow

////// if (i >= 0 && i < totalSamples)

////// {

////// outputSamples[i] = obj.SavedAmplitudes[i - obj.StartSampleIndex];

////// }

////// string outPath = Path.Combine(outputFolder, $"Rank_{group.Rank:D3}.wav");

////// WriteMono16BitPCM_WAV(outPath, outputSamples, sampleRate);

////// }

////// //////public static void GenerateRankedSpectralWavFiles(

////// ////// List<CrestTroughObject> allCrestTroughObjects,

////// ////// int totalSamples,

////// ////// int sampleRate,

////// ////// string outputFolder)

public static void SAVE_6_DIFFERENT_ZERO_LINE_SHIFTED_WAV_FILES_WITH_SIGNED_AVERAGES_AND_STANDARD_DEVIATIONS___AFTER_SAAN_NORMALIZED_DXF_GENERATIONS_COMPLETES(string input_wavfilespath)

{

////////c

//////public static int PUBLIC_STATIC_INT___THE_SAMPLES_PER_sECOND_FOUND_WHILE_READING = 8000;

////////CALLING CONVENTIONS

////////CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

//////public static double PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES = 0;

//////public static double PUBLIC_STATIC_DOUBLE_AVERAGE_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES = 0;

//////public static int PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE = 0;

////////we populate these at CALL_THIS_BEFORE_GENERATING___RANKED_WAV_FILES___ExportDxf_With_CREST_TROUGH_COUNTER_AS_Y_VALUES___SAAN_STYLES_SINGLE_OUTER_GRAPH_SAANS_NORMALIZED_SCALED_TO_MAX_WIDTH_CG_X_DATABoxesAndText

//////public static float[] PUBLIC_STATIC_FLOAT_ARRAY____RAW_SAMPLES_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES = null;

//////public static float[] PUBLIC_STATIC_FLOAT_ARRAY____RECONSTRUCTED_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES = null;

// After float[] allSamples is filled using fast chunked reading logic

float[] allSamples =

//...; // Assume already populated

.PUBLIC_STATIC_FLOAT_ARRAY____RAW_SAMPLES_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES;

int totalSamples = allSamples.Length;

// Step 1: Compute mean and stddev

double sum = 0;

foreach (float f in allSamples) sum += f;

double mean = sum / totalSamples;

double variance = 0;

foreach (float f in allSamples) variance += (f - mean) * (f - mean);

double stddev = Math.Sqrt(variance / totalSamples);

// Prepare all output variants

float[] file1 = new float[totalSamples]; // shifted mean to zero

float[] file2 = new float[totalSamples]; // shifted mean+std to zero

float[] file3 = new float[totalSamples]; // shifted mean-std to zero

float[] file4 = new float[totalSamples]; // ±10000 if > mean

float[] file5 = new float[totalSamples]; // ±10000 if > mean+std

float[] file6 = new float[totalSamples]; // ±10000 if > mean-std

float[] fileForMediansZeros = new float[totalSamples]; // ±10000 if > mean-std

//////for (int i = 0; i < totalSamples; i++)

//////{

////// float val = allSamples[i];

////// float absVal = Math.Abs(val);

////// file1[i] = (float)(val - mean);

////// file2[i] = (float)(val - (mean + stddev));

////// file3[i] = (float)(val - (mean - stddev));

////// file4[i] = absVal > mean ? (val > 0 ? +10000f : -10000f) : 0f;

////// file5[i] = absVal > (mean + stddev) ? (val > 0 ? +10000f : -10000f) : 0f;

////// file6[i] = absVal > (mean - stddev) ? (val > 0 ? +10000f : -10000f) : 0f;

//////}// for (int i = 0; i < totalSamples; i++)

///

// Step: Compute median

float[] sorted = (float[])allSamples.Clone();

Array.Sort(sorted);

float median = (totalSamples % 2 == 0)

? (sorted[totalSamples / 2 - 1] + sorted[totalSamples / 2]) / 2f

: sorted[totalSamples / 2];

for (int i = 0; i < totalSamples; i++)

{

float val = allSamples[i];

// 1–3: zero-line shifted

file1[i] = val - (float)mean;

file2[i] = val - (float)(mean + stddev);

file3[i] = val - (float)(mean - stddev);

// 4–6: audible binary encoding by direct val (NOT absVal)

file4[i] = (val > mean || val < -mean) ? (val > 0 ? +10000f : -10000f) : 0f;

file5[i] = (val > (mean + stddev) || val < -(mean + stddev)) ? (val > 0 ? +10000f : -10000f) : 0f;

file6[i] = (val > (mean - stddev) || val < -(mean - stddev)) ? (val > 0 ? +10000f : -10000f) : 0f;

fileForMediansZeros[i] = val - median; // ← Median-centered zero-line

}//for (int i = 0; i < totalSamples; i++)

// Save using same sample rate and bit depth

string folder = Path.GetDirectoryName(input_wavfilespath);

string baseName = Path.GetFileNameWithoutExtension(input_wavfilespath);

int sampleRate = 8000;

sampleRate

PUBLIC_STATIC_INT___THE_SAMPLES_PER_sECOND_FOUND_WHILE_READING;

// public static List<double> DetectBeats(float[] samples, int sampleRate, double thresholdPercent = 0.65)

double thresholdPercent = 0.65;

List<double> ___temp_beats_list= DetectBeats(allSamples, sampleRate, thresholdPercent); ;

StringBuilder ___strbldrforbts = new StringBuilder();

___strbldrforbts.Clear();

foreach (double ___btpoints in ___temp_beats_list)

{

___strbldrforbts

.AppendLine(___btpoints.ToString("F3"));

}//foreach(double ___btpoints in ___temp_beats_list)

System.IO.File.WriteAllText

(

Path.Combine(folder, baseName + "_the_btsdetected.txt")

___strbldrforbts.ToString()

);

// public static List<string> Get30msFrequencyReport(float[] samples, int sampleRate)

List<string> ___temp_30_milliseconds_frequency_reports= Get30msFrequencyReport(allSamples, sampleRate);

StringBuilder ___strbldrfor___30_millis_freqs_reports = new StringBuilder();

___strbldrfor___30_millis_freqs_reports.Clear();

List<string> ___temp_100_milliseconds_frequency_reports = Get100msFrequencyReport(allSamples, sampleRate);

//////var freqReport = Get30msFrequencyReport(allSamples, sampleRate);

//////File.WriteAllLines("FrequencyReport_30ms.csv", freqReport);

File.WriteAllLines(Path.Combine(folder, baseName + "___strbldrfor___100_millis_freqs_reports.txt"), ___temp_100_milliseconds_frequency_reports);

//*.dataGridView___COMPOSER

var reportLines = Get100msFrequencyReport(allSamples, sampleRate);

ConvertFrequencyReportToNoteFile

(reportLines

Path.Combine(folder, baseName + "___strbldrfor___100_millis_freqs_reports.dataGridView___COMPOSER")

);

foreach (string entryof30millisfreqsreports in ___temp_30_milliseconds_frequency_reports)

{

___strbldrfor___30_millis_freqs_reports

.AppendLine(entryof30millisfreqsreports);

}//foreach (string entryof30millisfreqsreports in ___temp_30_milliseconds_frequency_reports)

/////////////////////////////////////////////////////////////////////////////////////////////////////////

System.IO.File.WriteAllText

(

Path.Combine(folder, baseName + "___strbldrfor___30_millis_freqs_reports.txt")

___strbldrfor___30_millis_freqs_reports.ToString()

);

/////////////////////////////////////////////////////////////////////////////////////////////////////////

WriteMono32BitFloatPCM_WAV_WithNormalization(Path.Combine(folder, baseName + "_file1_mean_centered.wav"), file1, sampleRate);

WriteMono32BitFloatPCM_WAV_WithNormalization(Path.Combine(folder, baseName + "_file2_mean_plus_std_centered.wav"), file2, sampleRate);

WriteMono32BitFloatPCM_WAV_WithNormalization(Path.Combine(folder, baseName + "_file3_mean_minus_std_centered.wav"), file3, sampleRate);

WriteMono32BitFloatPCM_WAV_WithNormalization(Path.Combine(folder, baseName + "_file4_gt_mean_flagged.wav"), file4, sampleRate);

WriteMono32BitFloatPCM_WAV_WithNormalization(Path.Combine(folder, baseName + "_file5_gt_mean_plus_std_flagged.wav"), file5, sampleRate);

WriteMono32BitFloatPCM_WAV_WithNormalization(Path.Combine(folder, baseName + "_file6_gt_mean_minus_std_flagged.wav"), file6, sampleRate);

WriteMono32BitFloatPCM_WAV_WithNormalization(Path.Combine(folder, baseName + "_file6_gt_medians_centered.wav"), fileForMediansZeros, sampleRate);

}//public static void SAVE_6_DIFFERENT_ZERO_LINE_SHIFTED_WAV_FILES_WITH_SIGNED_AVERAGES_AND_STANDARD_DEVIATIONS___AFTER_SAAN_NORMALIZED_DXF_GENERATIONS_COMPLETES(string input_wavfilespath)

/// <summary>

/// ////////////////////////////////////////////////////////////////////////////////////////////////////////////

/// </summary>

/// <param name="allCrestTroughObjects"></param>

/// <param name="inputFilePath"></param>

public static void GenerateRankedSpectralCSVReport

(

List<CrestTroughObject> allCrestTroughObjects,

string inputFilePath

)

{

string outputFolder = Path.GetDirectoryName(inputFilePath);

string csvReportPath = Path.Combine(outputFolder, "RANk_WISE_ORDERED_CREST_TROUGH_COUNTER_TO_RANKED_REPORT.csv");

var rankedGroups = allCrestTroughObjects

.GroupBy(obj => Math.Round(obj.PUBLIC_DOUBLE_NON_DUPLICATE_CG_X_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS, 6))

.OrderBy(g => g.Key)

.Select((group, rankIndex) => new

{

Rank = rankIndex + 1,

Objects = group.ToList()

})

.ToList();

foreach (var group in rankedGroups)

{

foreach (var obj in group.Objects)

{

obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS = group.Rank;

}

StringBuilder csvBuilder = new StringBuilder();

csvBuilder.AppendLine("Overall_Serial_Number,Rank_X_CG_X_Order,Width_Microseconds,Sample_Count");

foreach (var group in rankedGroups)

{

foreach (var obj in group.Objects)

{

int sampleCount = obj.EndSampleIndex - obj.StartSampleIndex + 1;

csvBuilder.AppendLine(

obj.OVERALL_AABB_COUNTER_EITHER_IT_IS_CREST_OR_IT_IS_TROUGH____COUNTER_TO_RECONSTRUCTION_THE_ACTUAL_QUEUE_STRUCTURE_FROM_THE_STACK_ANALYSIS_DATA + "," +

obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS + "," +

obj.WidthMicroseconds + "," +

sampleCount

);

}

File.WriteAllText(csvReportPath, csvBuilder.ToString());

StringBuilder csvBuilderOrderByCRESTTROUGHOVERALLNUMBERS = new StringBuilder();

csvBuilderOrderByCRESTTROUGHOVERALLNUMBERS.AppendLine("Overall_Serial_Number,Rank_X_CG_X_Order,Width_Microseconds,Sample_Count");

var allRankedObjectsOrderedByOverallCounter = allCrestTroughObjects

.OrderBy(obj => obj.OVERALL_AABB_COUNTER_EITHER_IT_IS_CREST_OR_IT_IS_TROUGH____COUNTER_TO_RECONSTRUCTION_THE_ACTUAL_QUEUE_STRUCTURE_FROM_THE_STACK_ANALYSIS_DATA)

.ToList();

foreach (var obj in allRankedObjectsOrderedByOverallCounter)

{

int sampleCount = obj.EndSampleIndex - obj.StartSampleIndex + 1;

csvBuilderOrderByCRESTTROUGHOVERALLNUMBERS.AppendLine(

obj.OVERALL_AABB_COUNTER_EITHER_IT_IS_CREST_OR_IT_IS_TROUGH____COUNTER_TO_RECONSTRUCTION_THE_ACTUAL_QUEUE_STRUCTURE_FROM_THE_STACK_ANALYSIS_DATA + "," +

obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS + "," +

obj.WidthMicroseconds + "," +

sampleCount

);

}

string csvReportPath_orderby_cresttroughnumbers = Path.Combine(outputFolder, "CRESTTROUGH_NUMBER_WISE_ORDERED_CREST_TROUGH_COUNTER_TO_RANKED_REPORT.csv");

File.WriteAllText(csvReportPath_orderby_cresttroughnumbers + "_orderby_cresttroughnumbers.csv", csvBuilderOrderByCRESTTROUGHOVERALLNUMBERS.ToString());

}//

//////public static void GenerateRankedSpectralCSVReport

//////(

//////List<CrestTroughObject> allCrestTroughObjects,

//////string inputFilePath

//////)

public static void GenerateRankedSpectralWavFiles______DONT_CALL_THIS_BEFORE_ALL_DXF_PREPARED_SINCE_DXF_GENERATORS_POPULATE_SCALED_CG_X_DATA

(

List<CrestTroughObject> allCrestTroughObjects,

int totalSamples,

int sampleRate,

string inputFilePath

)

{

string outputFolder = Path.GetDirectoryName(inputFilePath);

StringBuilder ___strbldr = new StringBuilder();

___strbldr.Clear();

var rankedGroups = allCrestTroughObjects

.GroupBy(obj => Math.Round(obj.PUBLIC_DOUBLE_NON_DUPLICATE_CG_X_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS, 6))

.OrderBy(g => g.Key)

.Select((group, rankIndex) => new

{

Rank = rankIndex + 1,

Objects = group.ToList()

})

.ToList();

double ___total_populated_samples_for_current_output_files = 0;

foreach (var group in rankedGroups)

{

foreach (var obj in group.Objects)

{

obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS = group.Rank;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

foreach (var group in rankedGroups)

{

short[] outputSamples = new short[totalSamples];

___total_populated_samples_for_current_output_files = 0;

___strbldr.Clear();

foreach (var obj in group.Objects)

{

___strbldr.AppendLine

(

"CURRENT CREST_TROUGH_OBJECT OVERALL COUNTER = " + obj.OVERALL_AABB_COUNTER_EITHER_IT_IS_CREST_OR_IT_IS_TROUGH____COUNTER_TO_RECONSTRUCTION_THE_ACTUAL_QUEUE_STRUCTURE_FROM_THE_STACK_ANALYSIS_DATA

+"\r\n"+

"CURRENT CREST_TROUGH_OBJECT CREST COUNTER = " + obj.CREST_COUNTER

+ "\r\n" +

"CURRENT CREST_TROUGH_OBJECT TROUGH COUNTER = " + obj.TROUGH_COUNTER

+ "\r\n" +

"CURRENT CREST_TROUGH_OBJECT WIDTH MICROS = " + obj.WidthMicroseconds

+ "\r\n" +

"CURRENT CREST_TROUGH_OBJECT MaxAmplitude = " + obj.MaxAmplitude

+ "\r\n" +

"CURRENT CREST_TROUGH_OBJECT LocalMaximaCount = " + obj.LocalMaximaCount

+ "\r\n" +

"CURRENT CREST_TROUGH_OBJECT LocalMinimaCount = " + obj.LocalMinimaCount

+ "\r\n" +

"overall max width found in whole files = " +

.PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS

+ "\r\n" +

"CURRENT CREST_TROUGH_OBJECT TotalSamples = " + (obj.EndSampleIndex-obj.StartSampleIndex + 1)

+ "\r\nRANK CG_X_NORMALIZED AMPS samplecounter"

);

int length = obj.EndSampleIndex - obj.StartSampleIndex + 1;

for (int i = 0; i < length; i++)

{

int sampleIndex = obj.StartSampleIndex + i;

if (sampleIndex >= 0 && sampleIndex < totalSamples)

{

float amplitude = obj.LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES[i];

___total_populated_samples_for_current_output_files++;

___strbldr.AppendLine

(

group.Rank + " " +

// obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS + " " +

obj.PUBLIC_DOUBLE_NON_DUPLICATE_CG_X_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS + " " +

amplitude / 10000f + " " +

___total_populated_samples_for_current_output_files

);

outputSamples[sampleIndex] = (short)Math.Max(short.MinValue, Math.Min(short.MaxValue, amplitude));

}

string outFileName = $"RANKED_SPECTRAL_LINE_pushed_samples_{___total_populated_samples_for_current_output_files}_rank_{group.Rank:D3}.wav";

string outPath = Path.Combine(outputFolder, outFileName);

System.IO.File.WriteAllText(outPath + "_report.txt", ___strbldr.ToString());

if (___total_populated_samples_for_current_output_files > sampleRate)

{

// WriteMono16BitPCM_WAV(outPath, outputSamples, sampleRate);

WriteMono16BitPCM_WAV___takes_short_type_arrays(outPath, outputSamples, sampleRate);

}

// STEP 4: CLUBBED RANK WAV FILES

int[][] rankGroupsToClub = new int[][]

{

new int[] { 1, 2 },

new int[] { 1, 2, 3 },

new int[] { 1, 2, 3 ,4 },

new int[] { 1, 2, 3 ,4 ,5},

new int[] { 1, 2, 3, 4, 5, 6 },

new int[] { 1, 2, 3, 4, 5, 6 ,7},

new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }

};

foreach (var rankSet in rankGroupsToClub)

{

short[] clubbedSamples = new short[totalSamples];

double totalClubbedSamples = 0;

StringBuilder reportBuilder = new StringBuilder();

foreach (var rank in rankSet)

{

var group = rankedGroups.FirstOrDefault(g => g.Rank == rank);

if (group == null) continue;

foreach (var obj in group.Objects)

{

int len = obj.EndSampleIndex - obj.StartSampleIndex + 1;

for (int i = 0; i < len; i++)

{

int sampleIndex = obj.StartSampleIndex + i;

if (sampleIndex >= 0 && sampleIndex < totalSamples)

{

float amplitude = obj.LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES[i];

clubbedSamples[sampleIndex] = (short)Math.Max(short.MinValue, Math.Min(short.MaxValue, amplitude));

totalClubbedSamples++;

reportBuilder.AppendLine(

"Rank_" + rank + " " +

obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS + " " +

(amplitude / 10000f).ToString("F6") + " " +

totalClubbedSamples.ToString("F0")

);

}

string label = "rank_" + string.Join("_", rankSet.Select(r => r.ToString("D2")));

string wavFilePath = Path.Combine(outputFolder, $"CLUBBED_RANKED_SPECTRAL_LINE_{label}.wav");

string reportFilePath = wavFilePath + "_report.txt";

System.IO.File.WriteAllText(reportFilePath, reportBuilder.ToString());

if (totalClubbedSamples > sampleRate)

{

/// WriteMono16BitPCM_WAV(wavFilePath, clubbedSamples, sampleRate);

WriteMono16BitPCM_WAV___takes_short_type_arrays(wavFilePath, clubbedSamples, sampleRate);

}//if (totalClubbedSamples > sampleRate)

}// foreach (var rankSet in rankGroupsToClub)

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////// ADDITIONAL CLUBBED OUTPUTS FOR LAST N RANKS (up to last 8)

int totalRanks = rankedGroups.Count;

for (int n = 2; n <= 8; n++)

{

if (n > totalRanks) break;

var lastRankSet = Enumerable.Range(totalRanks - n + 1, n).ToArray();

short[] clubbedLastSamples = new short[totalSamples];

double totalClubbedLastSamples = 0;

StringBuilder reportBuilder = new StringBuilder();

foreach (var rank in lastRankSet)

{

var group = rankedGroups.FirstOrDefault(g => g.Rank == rank);

if (group == null) continue;

foreach (var obj in group.Objects)

{

int len = obj.EndSampleIndex - obj.StartSampleIndex + 1;

for (int i = 0; i < len; i++)

{

int sampleIndex = obj.StartSampleIndex + i;

if (sampleIndex >= 0 && sampleIndex < totalSamples)

{

float amplitude = obj.LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES[i];

clubbedLastSamples[sampleIndex] = (short)Math.Max(short.MinValue, Math.Min(short.MaxValue, amplitude));

totalClubbedLastSamples++;

reportBuilder.AppendLine(

"Rank_" + rank + " " +

obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS + " " +

(amplitude / 10000f).ToString("F6") + " " +

totalClubbedLastSamples.ToString("F0")

);

}// if (sampleIndex >= 0 && sampleIndex < totalSamples)

}

string label = "last_" + n + "_ranks_" + string.Join("_", lastRankSet.Select(r => r.ToString("D2")));

string wavFilePath = Path.Combine(outputFolder, $"LAST_RANKED_CLUBBED_SPECTRAL_LINE_{label}.wav");

string reportFilePath = wavFilePath + "_report.txt";

System.IO.File.WriteAllText(reportFilePath, reportBuilder.ToString());

if (totalClubbedLastSamples > sampleRate)

{

WriteMono16BitPCM_WAV___takes_short_type_arrays(wavFilePath, clubbedLastSamples, sampleRate);

}// if (totalClubbedSamples > sampleRate)

}// for (int n = 2; n <= 8; n++)

//////////////////////////////////////////////////////////////////////////////////////////////////

//////////// ///

//////////// // ADDITIONAL ANALYTIC BINARIZED OUTPUTS FOR TOP CLUBBED RANKS: 1, 1+2, 1+2+3

//////////// int[][] topRankSets = new int[][]

//////////// {

////////////new int[] { 1 },

////////////new int[] { 1, 2 },

////////////new int[] { 1, 2, 3 }

//////////// };

//////////// foreach (var rankSet in topRankSets)

//////////// {

//////////// string label = "top_rank_" + string.Join("_", rankSet.Select(r => r.ToString("D2")));

//////////// // Collect absolute amplitudes for this rank set

//////////// List<float> absoluteAmplitudes = new List<float>();

//////////// short[] originalSamples = new short[totalSamples];

//////////// foreach (var rank in rankSet)

//////////// {

//////////// var group = rankedGroups.FirstOrDefault(g => g.Rank == rank);

//////////// if (group == null) continue;

//////////// foreach (var obj in group.Objects)

//////////// {

//////////// int len = obj.EndSampleIndex - obj.StartSampleIndex + 1;

//////////// for (int i = 0; i < len; i++)

//////////// {

//////////// int index = obj.StartSampleIndex + i;

//////////// if (index >= 0 && index < totalSamples)

//////////// {

//////////// float amp = obj.LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES[i];

//////////// originalSamples[index] = (short)Math.Max(short.MinValue, Math.Min(short.MaxValue, amp));

//////////// absoluteAmplitudes.Add(Math.Abs(amp));

//////////// }

//////////// if (absoluteAmplitudes.Count == 0) continue;

//////////// // Compute mean and stddev of absolute amplitudes

//////////// double mean = absoluteAmplitudes.Average();

//////////// double stddev = Math.Sqrt(absoluteAmplitudes.Sum(x => Math.Pow(x - mean, 2)) / absoluteAmplitudes.Count);

//////////// // Threshold variants

//////////// var thresholds = new[]

//////////// {

//////////// new { Label = "gt_mean_minus_1stddev", Threshold = mean - stddev },

//////////// new { Label = "gt_mean", Threshold = mean },

//////////// new { Label = "gt_mean_plus_1stddev", Threshold = mean + stddev }

////////////};

//////////// foreach (var th in thresholds)

//////////// {

//////////// short[] binarySamples = new short[totalSamples];

//////////// int countMarked = 0;

//////////// StringBuilder report = new StringBuilder();

//////////// for (int i = 0; i < totalSamples; i++)

//////////// {

//////////// if (Math.Abs(originalSamples[i]) > th.Threshold)

//////////// {

//////////// binarySamples[i] = 1;

//////////// countMarked++;

//////////// }

//////////// else

//////////// {

//////////// binarySamples[i] = 0;

//////////// }

//////////// report.AppendLine("Report for " + label + " | Threshold = " + th.Threshold.ToString("F3"));

//////////// report.AppendLine("Total activated samples = " + countMarked);

//////////// report.AppendLine("Total samples = " + totalSamples);

//////////// report.AppendLine("Percentage activated = " + ((100.0 * countMarked) / totalSamples).ToString("F2") + "%");

//////////// string outPath = Path.Combine(outputFolder, $"TOPCLUBBED_BINARIZED_{label}_{th.Label}.wav");

//////////// string txtReportPath = outPath + "_report.txt";

//////////// File.WriteAllText(txtReportPath, report.ToString());

//////////// if (countMarked > sampleRate)

//////////// {

//////////// WriteMono16BitPCM_WAV___takes_short_type_arrays(outPath, binarySamples, sampleRate);

//////////// }//if (countMarked > sampleRate)

//////////// }

//////////// }//foreach (var rankSet in topRankSets)

// ADDITIONAL ANALYTIC BINARIZED OUTPUTS FOR TOP CLUBBED RANKS: 1, 1+2, 1+2+3

int[][] topRankSets = new int[][]

{

new int[] { 1 },

new int[] { 1, 2 },

new int[] { 1, 2, 3 },

new int[] { 1, 2, 3 ,4 },

new int[] { 1, 2, 3 ,4 , 5},

new int[] { 1, 2, 3 ,4 , 5 , 6},

new int[] { 1, 2, 3 ,4 , 5 , 6 , 7},

new int[] { 1, 2, 3 ,4 , 5 , 6 , 7 , 8}

};

foreach (var rankSet in topRankSets)

{

string label = "top_rank_" + string.Join("_", rankSet.Select(r => r.ToString("D2")));

// Collect absolute amplitudes for this rank set

List<float> absoluteAmplitudes = new List<float>();

short[] originalSamples = new short[totalSamples];

foreach (var rank in rankSet)

{

var group = rankedGroups.FirstOrDefault(g => g.Rank == rank);

if (group == null) continue;

foreach (var obj in group.Objects)

{

int len = obj.EndSampleIndex - obj.StartSampleIndex + 1;

for (int i = 0; i < len; i++)

{

int index = obj.StartSampleIndex + i;

if (index >= 0 && index < totalSamples)

{

float amp = obj.LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES[i];

short clamped = (short)Math.Max(short.MinValue, Math.Min(short.MaxValue, amp));

originalSamples[index] = clamped;

absoluteAmplitudes.Add(Math.Abs(clamped));

}// if (index >= 0 && index < totalSamples)

}//for (int i = 0; i < len; i++)

}//foreach (var obj in group.Objects)

if (absoluteAmplitudes.Count == 0) continue;

// Compute mean and stddev of absolute amplitudes

double mean = absoluteAmplitudes.Average();

double stddev = Math.Sqrt(absoluteAmplitudes.Sum(x => Math.Pow(x - mean, 2)) / absoluteAmplitudes.Count);

// Threshold variants

var thresholds = new[]

{

new { Label = "gt_mean_minus_1stddev", Threshold = mean - stddev },

new { Label = "gt_mean", Threshold = mean },

new { Label = "gt_mean_plus_1stddev", Threshold = mean + stddev }

};

foreach (var th in thresholds)

{

short[] binarySamples = new short[totalSamples];

int countMarked = 0;

StringBuilder report = new StringBuilder();

for (int i = 0; i < totalSamples; i++)

{

short original = originalSamples[i];

short absValue = (short)Math.Abs(original);

if (absValue > th.Threshold)

{

binarySamples[i] = (short)(original > 0 ? 10000 : -10000); // preserve sign and scale to ±10000

countMarked++;

}

else

{

binarySamples[i] = 0;

}

report.AppendLine("Report for " + label + " | Threshold = " + th.Threshold.ToString("F3"));

report.AppendLine("Total activated samples = " + countMarked);

report.AppendLine("Total samples = " + totalSamples);

report.AppendLine("Percentage activated = " + ((100.0 * countMarked) / totalSamples).ToString("F2") + "%");

string outPath = Path.Combine(outputFolder, $"TOPCLUBBED_BINARIZED_{label}_{th.Label}.wav");

string txtReportPath = outPath + "_report.txt";

File.WriteAllText(txtReportPath, report.ToString());

if (countMarked > sampleRate)

{

WriteMono16BitPCM_WAV___takes_short_type_arrays(outPath, binarySamples, sampleRate);

}

}// foreach (var rankSet in topRankSets)

}//public static void GenerateRankedSpectralWavFiles______DONT_CALL_THIS_BEFORE_ALL_DXF_PREPARED_SINCE_DXF_GENERATORS_POPULATE_SCALED_CG_X_DATA

public static void DISCARDED___SINCE_WE_ARE_ENHANCING_THE_FUNCTION______________________GenerateRankedSpectralWavFiles______DONT_CALL_THIS_BEFORE_ALL_DXF_PREPARED_SINCE_DXF_GENERATORS_POPULATE_SCALED_CG_X_DATA

(

List<CrestTroughObject> allCrestTroughObjects,

int totalSamples,

int sampleRate,

// string outputFolder

string inputFilePath

)

{

//string inputFilePath = @"F:\mywaves\inputfile.wav";

string outputFolder = Path.GetDirectoryName(inputFilePath);

StringBuilder ___strbldr = new StringBuilder();

___strbldr.Clear();

//to do thenby PUBLIC_DOUBLE_NON_DUPLICATE_CG_Y_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_HEIGHTS_OF_ALL_AABB_OBJECTS

// STEP 1: Rank the objects by unique CG_X (normalized, non-duplicate version)

var rankedGroups = allCrestTroughObjects

.GroupBy(obj => Math.Round(obj.PUBLIC_DOUBLE_NON_DUPLICATE_CG_X_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS, 6))

.OrderBy(g => g.Key)

.Select((group, rankIndex) => new

{

Rank = rankIndex + 1,

Objects = group.ToList()

})

.ToList();

double ___total_populated_samples_for_current_output_files = 0;

// STEP 2: Assign rank index to each object's CG_X rank field

foreach (var group in rankedGroups)

{

foreach (var obj in group.Objects)

{

obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS = group.Rank;

}//foreach (var obj in group.Objects)

}//foreach (var group in rankedGroups)

// STEP 3: Generate WAV for each rank

foreach (var group in rankedGroups)

{

short[] outputSamples = new short[totalSamples];

___total_populated_samples_for_current_output_files = 0;

foreach (var obj in group.Objects)

{

int length = obj.EndSampleIndex - obj.StartSampleIndex + 1;

for (int i = 0; i < length; i++)

{

int sampleIndex = obj.StartSampleIndex + i;

if (sampleIndex >= 0 && sampleIndex < totalSamples)

{

float amplitude = obj.LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES[i];

___total_populated_samples_for_current_output_files++;

___strbldr

.AppendLine

(

group.Rank

+ " " +

obj.PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS

+ " " +

amplitude/10000f

+" " +

___total_populated_samples_for_current_output_files

);

outputSamples[sampleIndex] = (short)Math.Max(short.MinValue, Math.Min(short.MaxValue, amplitude));

}//if (sampleIndex >= 0 && sampleIndex < totalSamples)

}//for (int i = 0; i < length; i++)

}//foreach (var obj in group.Objects)

string outFileName = $"RANKED_SPECTRAL_LINE_pushed_samples_{___total_populated_samples_for_current_output_files}_rank_{group.Rank:D3}.wav";

string outPath = Path.Combine(outputFolder, outFileName);

///////////////////////////////////////////////////////////////////

System.IO.File.WriteAllText

(

outPath + "_report.txt"

___strbldr.ToString()

);

///////////////////////////////////////////////////////////////////

///

if (___total_populated_samples_for_current_output_files> sampleRate)

{

// WriteMono16BitPCM_WAV(outPath, outputSamples, sampleRate);

WriteMono16BitPCM_WAV___takes_short_type_arrays(outPath, outputSamples, sampleRate);

}// if(___total_populated_samples_for_current_output_files> sampleRate)

else

{

}// if(___total_populated_samples_for_current_output_files> sampleRate)

}//foreach (var group in rankedGroups)

}

//////public static void GenerateRankedSpectralWavFiles______DONT_CALL_THIS_BEFORE_ALL_DXF_PREPARED_SINCE_DXF_GENERATORS_POPULATE_SCALED_CG_X_DATA(

////// List<CrestTroughObject> allCrestTroughObjects,

////// int totalSamples,

////// int sampleRate,

////// string outputFolder)

public static void WriteMono32BitFloatPCM_WAV_WithNormalization(string outPath, float[] samples, int sampleRate)

{

float maxAbs = samples.Select(x => Math.Abs(x)).Max();

if (maxAbs < 1e-6f) maxAbs = 1f; // Prevent division by zero

using (var bw = new BinaryWriter(File.Create(outPath)))

{

int byteRate = sampleRate * 4; // 4 bytes for 32-bit float

int subchunk2Size = samples.Length * 4;

int chunkSize = 36 + subchunk2Size;

// RIFF header

bw.Write(System.Text.Encoding.ASCII.GetBytes("RIFF"));

bw.Write(chunkSize);

bw.Write(System.Text.Encoding.ASCII.GetBytes("WAVE"));

// fmt subchunk

bw.Write(System.Text.Encoding.ASCII.GetBytes("fmt "));

bw.Write(16); // PCM format chunk size

bw.Write((short)3); // format code 3 = IEEE float

bw.Write((short)1); // mono

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)4); // block align

bw.Write((short)32); // bits per sample

// data subchunk

bw.Write(System.Text.Encoding.ASCII.GetBytes("data"));

bw.Write(subchunk2Size);

foreach (var sample in samples)

{

float normalized = sample / maxAbs;

bw.Write(normalized);

}// foreach (var sample in samples)

}// using (var bw = new BinaryWriter(File.Create(outPath)))

}// public static void WriteMono32BitFloatPCM_WAV_WithNormalization(string outPath, float[] samples, int sampleRate)

public static void DISCARDING___THIS_WAS_ALSO_WORKING_____________WriteMono32BitFloatPCM_WAV_WithNormalization(string outPath, float[] outputSamples, int sampleRate)

{

// Step 1: Normalize if needed (avoid distortion/clipping)

float maxAbs = outputSamples.Max(x => Math.Abs(x));

float normalizationFactor = (maxAbs > 1.0f) ? (1.0f / maxAbs) : 1.0f;

// Step 2: Prepare WAV parameters

int byteRate = sampleRate * 4; // mono, 32-bit float = 4 bytes per sample

int subchunk2Size = outputSamples.Length * 4;

int chunkSize = 36 + subchunk2Size;

// Step 3: Write WAV file

using (BinaryWriter bw = new BinaryWriter(File.Create(outPath)))

{

// RIFF Header

bw.Write(System.Text.Encoding.ASCII.GetBytes("RIFF"));

bw.Write(chunkSize);

bw.Write(System.Text.Encoding.ASCII.GetBytes("WAVE"));

// fmt subchunk (for 32-bit float PCM)

bw.Write(System.Text.Encoding.ASCII.GetBytes("fmt "));

bw.Write(16); // Subchunk1Size

bw.Write((short)3); // AudioFormat = 3 (IEEE float)

bw.Write((short)1); // NumChannels = 1 (Mono)

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)4); // BlockAlign

bw.Write((short)32); // BitsPerSample

// data subchunk

bw.Write(System.Text.Encoding.ASCII.GetBytes("data"));

bw.Write(subchunk2Size);

foreach (float sample in outputSamples)

{

bw.Write(sample * normalizationFactor);

}

}//public static void WriteMono32BitFloatPCM_WAV_WithNormalization(string outPath, float[] outputSamples, int sampleRate)

public static void WriteMono16BitPCM_WAV___takes_short_type_arrays(string outPath, short[] outputSamples, int sampleRate)

{

int byteRate = sampleRate * 2; // mono, 16-bit = 2 bytes per sample

int subchunk2Size = outputSamples.Length * 2;

int chunkSize = 36 + subchunk2Size;

using (BinaryWriter bw = new BinaryWriter(File.Create(outPath)))

{

// RIFF header

bw.Write(System.Text.Encoding.ASCII.GetBytes("RIFF"));

bw.Write(chunkSize);

bw.Write(System.Text.Encoding.ASCII.GetBytes("WAVE"));

// fmt subchunk

bw.Write(System.Text.Encoding.ASCII.GetBytes("fmt "));

bw.Write(16); // PCM

bw.Write((short)1); // audio format = 1 (PCM)

bw.Write((short)1); // mono

bw.Write(sampleRate);

bw.Write(byteRate);

bw.Write((short)2); // block align = numChannels * bitsPerSample/8

bw.Write((short)16); // bits per sample

// data subchunk

bw.Write(System.Text.Encoding.ASCII.GetBytes("data"));

bw.Write(subchunk2Size);

foreach (short sample in outputSamples)

{

bw.Write(sample);

}//foreach (short sample in outputSamples)

}//using (BinaryWriter bw = new BinaryWriter(File.Create(outPath)))

}//public static void WriteMono16BitPCM_WAV___takes_short_type_arrays(string outPath, short[] outputSamples, int sampleRate)

public static void ExportDxfWithBoxesAndCenterlines(List<CrestTroughObject> crestTroughs, string wavPath)

{

string path = Path.ChangeExtension(wavPath, "_GRAPH_CG_BOXES_AXES.dxf");

using (StreamWriter sw = new StreamWriter(path))

{

sw.WriteLine("0\nSECTION\n2\nENTITIES");

foreach (var ct in crestTroughs)

{

float cx = ct.CG.X;

float cy = ct.IsCrest ? ct.CG.Y : -Math.Abs(ct.CG.Y);

float radius = Math.Max(1f, (ct.EndSampleIndex - ct.StartSampleIndex) / 10f);

int color = ct.IsCrest ? 5 : 1;

sw.WriteLine($"0\nCIRCLE\n8\n0\n62\n{color}\n10\n{cx.ToString("F3", CultureInfo.InvariantCulture)}\n20\n{cy.ToString("F3", CultureInfo.InvariantCulture)}\n30\n0\n40\n{radius.ToString("F3", CultureInfo.InvariantCulture)}");

float x1 = cx - ct.BoundingBox.Width / 2;

float x2 = cx + ct.BoundingBox.Width / 2;

float y1 = ct.IsCrest ? 0 : -ct.BoundingBox.Height;

float y2 = ct.IsCrest ? ct.BoundingBox.Height : 0;

sw.WriteLine($"0\nLINE\n8\n0\n62\n{color}\n10\n{x1.ToString("F3", CultureInfo.InvariantCulture)}\n20\n{y1.ToString("F3", CultureInfo.InvariantCulture)}\n30\n0\n11\n{x2.ToString("F3", CultureInfo.InvariantCulture)}\n21\n{y2.ToString("F3", CultureInfo.InvariantCulture)}\n31\n0");

}

sw.WriteLine("0\nENDSEC\n0\nEOF");

}

}//public static void ExportDxfWithBoxesAndCenterlines(List<CrestTroughObject> crestTroughs, string wavPath)

public static void ExportCrestTroughGroupingPivot(List<CrestTroughObject> crestTroughs, string wavPath)

{

string path = Path.ChangeExtension(wavPath, "_GROUP_PIVOT.csv");

using (StreamWriter sw = new StreamWriter(path))

{

sw.WriteLine("Type,GroupKey,Count");

var crestGroups = crestTroughs.Where(c => c.IsCrest).GroupBy(c => $"{(int)(c.WidthMicroseconds / 1000)}ms_{(int)(c.HeightAmplitude * 1000)}amp_{(int)(c.AreaProportion * 1000)}aprop");

var troughGroups = crestTroughs.Where(c => !c.IsCrest).GroupBy(c => $"{(int)(c.WidthMicroseconds / 1000)}ms_{(int)(c.HeightAmplitude * 1000)}amp_{(int)(c.AreaProportion * 1000)}aprop");

foreach (var g in crestGroups)

sw.WriteLine($"CREST,{g.Key},{g.Count()}");

foreach (var g in troughGroups)

sw.WriteLine($"TROUGH,{g.Key},{g.Count()}");

}

}// public static void ExportCrestTroughGroupingPivot(List<CrestTroughObject> crestTroughs, string wavPath)

public static void ExportBitmapWithBoxesAndAxes(List<CrestTroughObject> crestTroughs, string wavPath, float widthScale, float heightScale, float maxWidth, float maxHeight, int bmpWidth, int bmpHeight)

{

//////float maxWidth = Math.Max(1f, filtered.Max(ct => ct.WidthMicroseconds));

//////float maxHeight = Math.Max(1f, filtered.Max(ct => Math.Abs(ct.CG.Y)));

//////float widthScale = maxWidth > 1000f ? 1000f / maxWidth : 1f;

//////float heightScale = maxHeight > 1f ? 100f / maxHeight : 1f;

//////int bmpWidth = Math.Max(64, (int)(maxWidth * widthScale) + 10);

//////int bmpHeight = Math.Max(64, (int)(filtered.Count * maxHeight * heightScale) + 10);

using (Bitmap bmp = new Bitmap(bmpWidth, bmpHeight))

{

Graphics g = Graphics.FromImage(bmp);

g.Clear(Color.White);

g.DrawLine(Pens.Black, 0, bmpHeight / 2, bmpWidth, bmpHeight / 2);

Font font = new Font("Arial", 7);

g.DrawString(Path.GetFileName(wavPath), font, Brushes.Black, 2, bmpHeight / 2);

int offsetY = 0;

foreach (var ct in crestTroughs)

{

PointF cg = ct.CG;

int x = (int)((cg.X / ct.WidthMicroseconds) * maxWidth * widthScale);

int y = ct.IsCrest

? (int)(bmpHeight / 2 - ((cg.Y / ct.HeightAmplitude) * maxHeight * heightScale))

: (int)(bmpHeight / 2 + ((Math.Abs(cg.Y) / ct.HeightAmplitude) * maxHeight * heightScale));

int radius = Math.Max(2, (ct.EndSampleIndex - ct.StartSampleIndex) / 128);

for (int dx = -radius; dx <= radius; dx++)

for (int dy = -radius; dy <= radius; dy++)

if (x + dx >= 0 && x + dx < bmp.Width && y + dy >= 0 && y + dy < bmp.Height)

bmp.SetPixel(x + dx, y + dy, ct.IsCrest ? Color.Blue : Color.Red);

Rectangle box = new Rectangle(

(int)(x - (ct.BoundingBox.Width * widthScale / 2)),

ct.IsCrest

? (int)(bmpHeight / 2 - ct.BoundingBox.Height * heightScale)

: (int)(bmpHeight / 2),

(int)(ct.BoundingBox.Width * widthScale),

(int)(ct.BoundingBox.Height * heightScale));

g.DrawRectangle(ct.IsCrest ? Pens.Blue : Pens.Red, box);

}

if (bmpWidth <= 0 || bmpHeight <= 0)

{

MessageBox.Show("Invalid bitmap dimensions. Aborting image save.");

return;

}//if (bmpWidth <= 0 || bmpHeight <= 0)

bmp.Save(Path.ChangeExtension(wavPath, "_GRAPH_CG_BOXES_AXES.bmp"));

}

}//public static void ExportBitmapWithBoxesAndAxes(List<CrestTroughObject> crestTroughs, string wavPath, float widthScale, float heightScale, float maxWidth, float maxHeight, int bmpWidth, int bmpHeight)

public class CrestTroughObject

{

//SANJOY NATH'S PROOF OF HIS CLAIMS IN SANJOY NATH'S QHENOMENOLOGY(Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS

//fourier tried to explain the different wave forms as vertical summation of amplitudes (superposition of multiple sinusoidal shapes) and due to that superpositions the cycles natures of waves changes. And when superpositions are done the waves (each cycles ) shapes changes and also the timeperiod (in microseconds) per shape cycle changes similarly the wave forms crest counts changes wave forms trough counts changes and ultimately we see one wave cycle has several crest and troughs involve to form single wave cycles... In conventional theory of waves frequency is described as the number of complete cycles per second(1000000 microsecond as width of a second along timelines) Fourier used to look at the complete cycle (zero crossing points as effect of superposition) But Sanjoy Nath looks at frequency as combinatorial packing factor of different AABB widths along the timeline. So in Sanjoy Nath's interprretation (not taking vertical superposition as cause of zero crossing instead considering zero crossing are the combinatorial counting property and CATALAN NUMBERS , Integer partitioning like reasoning over timeline is used which means whole wave cycles are partitioned as CREST AABB WIDTH in microseconds and TROUGH AABB Widths in microseconds ultimately whole wavecycle is summation of well partitioned different sized AABB objects and total energy in a wave form depends upon CG of all amplitudes in the all AABB objects of crest and Trough objects which governs the waves features energy is scalar and scalarly addable so pure arithmetic is applicable and total cycle width in microsecond is time period of wave which is same in Sanjoy Nath's Qhenomenology linear queue model of crests and troughs but combinatorial juxtapositions of crest AABB Trough AABB can also achieve same time period but wave cycle will not look like complete wave cycle but when stacked with left margins aligned for all these AABB objects will not hamper the CG positioningcycle ) Different Crest AABB Widths +6 Different Trough AABB Widths summed togather to form single wave cycle and that is TimePeriod of wave (as in conventional Theory of waves where superimposition of different sinusoidal components governs zero crossing points... Sanjoy Nath looks at these scanario from other point of view where Sanjoy Nath Takes zero crossing points as governing factors and Combinatorial clustering of Crest AABB Trough AABB and arranging these in specific strict ORDERED QUEUE OF particular CRESTS after PARTICULAR Troughs make a wave cycle and one time period is found but TOPOLOGICALLY that dont help us to think different kinds of QUEUING nor gives us bigger pictures of combinatorial packing problems of different sized AABB to achieve same cycle (Complete cycle of same Time Period) . On the other hand conventional theory of waves consider 1 second(1000000 micro second as reference) and number of complete time periods per second as frequency . In the conventional theory of waves it is considered that certain cycle shape is rolling on a horizontal surface and when one complete cycle complets then certain distance is covered per cycle but while plotting the waves and whole showing the wave lengths the conventional theory of waves show wave lengths along the time axis. Sanjoy Nath considers total wave lengths as total time covered per cycle so time period and wave lengths look geometrically same in Sanjoy Nath's Qhenomenology Theory of Waves. So number of complete widths of complete cycle (after queuing of Crests AABB Trough AABB the full cycle completes and total time period covered as T microseconds which is a PACKET OF sOME AABB objects) When T squizes then packing count increases which is actually frequency increases... Frequency is nothing but the packing factor of complete AABB of a complete cycle in 1000000 micro seconds length. When frequency is packing factor then it is a scale facor of widths. When scale factor s is involved that scales the x coordinates of all CG points ) So when single cycles AABB gets squized the frequency increases so X coordinate of CG of Whole cycle AABB also squizes and so proportionately x coordinates of all component Crest AABB and Trough AABB also squizes...) This way packing and partitioning of AABB Queue along time lines take different packing to form multi frequency waves. This justifies the horizontal AABB packing with conventional superimposition of waves(which are done vertically) Now consider the vertical sides that is Y values of CG for every AABB components... These vary due to frequency change and when the energy per CREST AABB and Energy per Trough AABB remains same horizontal squizing of AABB increases the Y values of CG (virtual bult modulus of these AABB to consider) So while stacking one AABB above another keeping left margins aligned will generate different y for differently squized x so vertical spectral lines are seen when we see the stacks of AABB from top views. This prooves the Justifications of conventional theory with Sanjoy Nath's Qhenomenological Theory of Waves

// AXIOM 1 SANJOY NATH'S QHENOMENOLOGY(Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS ARE NOT AT ALL CONSIDERING THE WAVES AS COMBINATIONS OF COS COMPONENTS AND SIN COMPONENTS. SO SANJOY NATH'S QHENOMENOLOGY REASONING ON DIGITAL SIGNAL PROCESSING WILL NEVER USE FOURIER PROCESS NOR USE FFT LIKE THINGS TO DO WAVES ANALYSIS OR DIGITAL SIGNAL PROCESSINGS

// AXIOM 2 SANJOY NATH'S QHENOMENOLOGY (Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS CONSIDERS A HORIZONTAL 0 0 LINE (ZERO AMPLITUDE LINE IS THERE WHICH IS AVERAGE OF ALL THE AMPLITUDES IN THE GLOBAL DATA OF FLUCTUATING AMPLITUDE LIKE VALUES AND ZERO CROSSING ARE CALCULATED WITH REFERENCE TO THIS 0 0 LINE WHICH IS AVERAGE VALUE LINE) AND AMPLITUDES BELOW THIS AVERAGE ARE NEGATIVE AMPLITUDES AND AMPLITUDES ABOVE THIS AVERAGE VALUE IS POSITIVE AMPLITUDES

// AXIOM 3 SANJOY NATH'S QHENOMENOLOGY (Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS CONSIDERS WAVES AS SERIES(STRICT QUEUES OF CREST AABB OBJECTS AND TROUGH AABB OBJECTS ) ALL THESE CREST AND TROUGH AABB OBJECTS ARE TRANSPARENT TRACING PAPERS LIKE AABBR RECTANGLES BOUNDING BOXES WHICH ALL HAVE SOME CENTER OF GRAVITY CALCULATED FROM THE POINTS OF AMPLITUDE TIPS BOUNDED INSIDE THESE CREST AND TROUGH AABB LIKE TRANSPARENT TRACING PAPER LIKE OBJECTS) FOR CREST OBJECTS THE ORIGIN OF AABB RECTANGULAR BOUNDING BOXES ARE AT LEFT BOTTOM CORNER OF THE RECTANGULAR BOUNDING BOXES AND FOR TROUGH LIKE OBJECTS THE ORIGIN IS AT LEFT TOP CORNER OF AABB RECTANGLE BOUNDING BOXES AND THESE ORIGINS ARE PLACED ON THE 0 0 (AVERAGE AMPLITUDE LINE ) SUCH THAT QUEUE LIKE SEQUENCE OF CREST TROUGH CREST TROUGH ARE PLACED ONE AFTER ANOTHER AND EVERY CREST OBJECT HAS A STRICT SEQUENCE NUMBER AND EVERY TROUGH HAS STRICT SEQUENCE NUMBER SO EVERY CREST AND TROUGH ARE UNIQUELY PLACED IN THE STRICT QUEUE TO GENERATE THE WHOLE WAVE OBJECT(WHOLE SIGNAL OBJECT)

// AXIOM 3+ SANJOY NATH'S QHENOMENOLOGY (Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS THE ANALYSIS STARTS WITH THE CONDITION THAT FORGET THE ACTUAL AMPLITUDES VALUES AND REMEMBERS ONLY THE MAX WIDTH OF EACH AABB (IN MICROSECONDS OR LIKE THAT MEASURE OR METRIK) , MAX HEIGHT OF EACH AABB(OR AMPLITUDE LIKE MEASURES METRIKS) CG , STANDARD DEVIATIONS OF AMPLITUDES , SKEWNESS OF AMPLITUDES , KURTOSIS OF AMPLITUDES IN THESTATISTICAL MOMENTS CALCULATED ON THE AMPLITUDES IN THE CREST AABB OBJECT OR IN THE TROUGH AABB OBJECTS ... THE ACTUAL AMPLITUDE VALUES ARE FORGOTTEN ENTIRELY WHILE DOING SIGNALS PROPERTY ANALYSIS)

// AXIOM 3++ SANJOY NATH'S QHENOMENOLOGY(Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS THE ANALYSIS IS DONE ON THE STACKS (DISMANTLED QUEUE OF CREST AABB AND TROUGH AABB AND THE QUEUE OBJECT IS TRANSFORMED TO (0,0) ALIGNED (LEFT MARGIN ALIGNED) AABB RECTANGLES BOUNDING BOXES SUCH THAT THE (AFTER DISMANTLED QUEUE AND STACKING DONE)STACK OF TRANSPARENT CREST BOUNDING BOXES AND TROUGH BOUNDING BOXES ARE PLACED IN STACK ALL THE LEFT MARGINS ARE ALIGNED AS OVERALL LEFT MARGINS (SANJOY NATH HAS TESTED ON 380000 SOUND WAV FILES DIGITAL WAV FILES) AND FOUND THAT CG (BLUE DOTS FOR CREST AABB AMPLITUDES) AND RED DOTS FOR CG ON THE TROUGH AABB AMPLITUDES) LIE ON THE VERTICAL LINES OF SPECTRUMS LIKE VERTICAL STRIPS WHEN ALL THESE TRANSPARENT RECTANGLES AABB BOUNDING BOXES (LEFT MARGIN ALIGNED ORIGINS OF ALL AABB RECTANGULAR TRACING PAPERS PLACED ON ORIGINS OF OTHERS SO THAT ALL ORIGINS ARE PLACED ON SAME LOCATION IN STACK) ARE SHOWING THAT IF THERE ARE N DIFFERENT FREQUENCIES PRESENT IN THE WAVE THEN THERE ARE N SHARP VERTICAL LINES ARE THERE IF WE LOOK AT THE STACK OF TRANSPARENT ALIGNED AABB OBJECTS WHICH SIGNIFIES THE FREQUENCY ANALYSIS IS EASIER TO HANDLE AND NO NEED OF FFT LIKE DATA HANDLING NECESSARY AT ALL NO NEED TO COS COMPONENTS NO NEED OF SIN COMPONENTS NECESSARY TO DO SPECTRAL ANALYSIS ON TEH WAVES LIKE OBJECTS.

// AXIOM 7 SANJOY NATH'S QHENOMENOLOGY(Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS HAS FOUND THAT(ON TESTING ON 380000 WAV FILES) THE TERMS LIKE WAVE LENGTH IS NOT NECESSARY TO ANALYSE WAVE LIKE DIGITAL SIGNALS THE TERMS LIKE FREQUENCY ARE NOT NECESSARY TO HANDLE DIGITAL SIGNAL PROCESSINGS NOR WE NEED THE COS COMPONENTS TO DESCRIBE WAVE LIKE DATA NOR WE NEED SIN COMPONENTS LIKE OBJECTS TO DESCRIBE WAVE OR DIGITAL SIGNAL LIKE DATA (THE QUEUE OF AABB RECTANGLES BEHAVE AS WAVE NATURE OF THE LIGHT AND STACKS OF SAME AABB RECTANGLES BEHAVE AS THE PARTICLE NATURE OF LIGHT AND SPECTRAL NATURE OF LIGHTS ARE NOTHING BUT THE ALIGNMENTS OF CG OF THESE AABB OBJECTS STACKED AND OBSERVED FROM TOP VIEWS) SANJOY NATH'S QHENOMENOLOGICAL REASONING ON THEORY OF WAVE IS COMPLETELY IGNORING THE TERMS LIKE FREQUENCY TERMS LIKE WAVE LENGTHS AND TREATS WAVES AS QUEUE OF AABB OBJECTS OR STACKS OF AABB OBJECTS

// AXIOM 6 SANJOY NATH'S QHENOMENOLOGY(Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS HAVE SEEN THAT IF THE CREST AABB BOXES HAS WIDTHS (IN MICRO SECONDS TAKEN) HAS W_C_1 , W_C_2 ... W_C_N AND THE WITHS IN MICROSECONDS FOR TROUGHS OBJECTS AS W_T_1 , W_T_2 ... W_T_N (TOTAL NUMBER OF CRESTS AND TOTAL NUMBER OF TROUGHS ARE NOT NECESSARILY SAME BECAUSE SOMETIMES THERE ARE JUST ZERO TOUCHING CRESTS AND JUST ZERO TOUCHING TROUGHS ARE THERE STILL THE PROPERTIES HOLDS) AFTER OBSERVING THE STACKS OF TRANSPARENT AABB OBJECTS ...... THE OBSERVATIONS ON 380000 WAVE FILES STUDY REVEALS THAT WHEN FREQUENCY OF SAME SOUND (TONE) INCREASES THE WIDTHS SQUIZES AND WHEN THE FREQUENCY OF SAME SOUND (TONE) DECREASES THEN THE WIDTHS OF CREST TROUGH INCREASES SO THE NUMBER OF CRESTS PER SECOND(1000000 MICROSECOND) CHANGES AS THE FREQUENCY (TONE) OF THE SOUND CHANGES AND NUMBER OF SHARP VERTICAL LINES (FORMED DUE TO ALIGNMENT OF SUCH MARKED CG POINTS)VISIBLE ON STACK OF TRANSPARENT AABB OF CREST OBJECTS AND TROUGH OBJECTS ULTIMATELY GIVES CLARITY OF NUMBER OF FREQUENCIES INVOLVED IN THE WAVE (SPECTRAL ANALYSIS IS EASY) SINCE ALL TEH CREST AND TROUGHS HAVE QUEUE_SERIAL_NUMBERS SO WE CAN RE ARRANGE THE STACK TO QUEUE AGAIN AFTER THE ANALYSIS IS DONE

// AXIOM 8 SANJOY NATH'S QHENOMENOLOGY (Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS WE PRESERVE THESE OVERALL_AABB_COUNTER_EITHER_IT_IS_CREST_OR_IT_IS_TROUGH____COUNTER_TO_RECONSTRUCTION_THE_ACTUAL_QUEUE_STRUCTURE_FROM_THE_STACK_ANALYSIS_DATA BEFORE STACKING DONE FROM THE QUEUE STRUCTURE AND WE CAN ALSO ALTER THE WHOLE SIGNAL TO RECONSTRUCT RANDOM VALUES OF AMPLITUDES FOR CREST AABB FOR TROUGH AABB PRESERVING THE GEOMETRY OF CG POINTS AS THESE ARE AND THESE KIND OF RECONSTRUCTIONS OF WAVES WITH COMPLETELY OTHER SETS OF AMPLITUDES WILL GENERATE SAME SPECTRAL BEHAVIORS AS THE ACTUAL WAVE OBJECTS THIS IS INTERESTING PROPERTY OF SANJOY NATH'S QHENOMENOLOGY PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS

// AXIOM 9 SANJOY NATH'S QHENOMENOLOGY (Dont confuse with Phenomenology , it is Qhenomenology which is entirely different thing) PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS CONSIDERS ALL PHOTON LIKE THINGS ARE NOT EXISTING WHILE INSTEAD THE WAVES CRESTS AND TROUGHS QUE DISMATLES TO STACKS OF AABB (AS IN THE AXIOMS HERE)WHILE LIGHT PASS THROUGH SLITS OR WHILE LIGHT PASS THROUGH CRYSTALS THE CREST AABB QUEUES AND TROUGH AABB QUEUES CLOOAPSES (DISMANTLES) AND THE STACKS ARE FORMED AS PER SANJOY NATHS DESCRIPTIONS IN SANJOY NATH'S QHENOMENOLOGY PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS SO WE GET THE SPECTRUMS OF CG ALIGNED WHICH WE MISTAKE AS FREQUENCY SPECTRUMS... SANJOY NATH'S QHENOMENOLOGY PHYSICS REASONING SYSTEMS ON WAVES AND DIGITAL SIGNALS CLAIMS THAT THESE ARE NOT AT ALL FREQUENCY SPECTRUMS BUT THESE ARE CG ALIGGNED ON STACKS OF AABB LOOKS LIKE VERTICAL LINE SPECTRUMS DUE TO STACKING OF CREST AABB STACKING OF TROUGH AABB OBJECTS

public int StartSampleIndex;

public int EndSampleIndex;

int sampleCount;

public float MaxAmplitude;

public float MinAmplitude;

public bool IsCrest;

public List<PointF> TipPointsMicrosecondsVsAmplitude = new List<PointF>();

public List<float> LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES = new List<float>();//SANJOY NATH NEEDS THESE TO RE GENERATE THE FILTERED WAV FILES

public List<float> LIST_OF_ALL_RECONSTRUCTED_SIN_WAVES_SAMPLES_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES = new List<float>();//SANJOY NATH NEEDS THESE TO RE GENERATE THE FILTERED WAV FILES

public List<float> LIST_OF_ALL_RECONSTRUCTED_SAMPLES_WHERE_AMPLITUDES_ARE_MIRROR_IMAGE_ABOUT_VERTICAL_LINE_WITHIN_CG_X_OF_CURRENT_CREST_TROUGH_AABB_SAMPLES_RANGE___FLOATING_VALUES_OF_ACTUAL_SAMPLES_AMPLITUDES_SWAPPED_AS_MIRROR_IMAGE_SAMPLE_INDEX___WE_WILL_RECONSTRUCT_WHOLE_WAVE_WITH_SUCH_MIRRORED_SAMPLES = new List<float>();//SANJOY NATH NEEDS THESE TO RE GENERATE THE FILTERED WAV FILES

public double CREST_COUNTER = 0;

public double TROUGH_COUNTER = 0;

public double OVERALL_AABB_COUNTER_EITHER_IT_IS_CREST_OR_IT_IS_TROUGH____COUNTER_TO_RECONSTRUCTION_THE_ACTUAL_QUEUE_STRUCTURE_FROM_THE_STACK_ANALYSIS_DATA = 0;

public RectangleF BoundingBox;

public RectangleF BoundingBox___NORMALIZED_ON_SCALED_AABB_WITH_REFERENCE_TO_GLOBAL_AABB_MAX_WIDTH_GLOBAL_AABB_MAX_AMPLITUDES;

public PointF CG;

public PointF CG___NORMALIZED_ON_SCALED_AABB_WITH_REFERENCE_TO_GLOBAL_AABB_MAX_WIDTH_GLOBAL_AABB_MAX_AMPLITUDES;

public double PUBLIC_DOUBLE_NON_DUPLICATE_CG_X_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS = 0;

public double PUBLIC_DOUBLE_NON_DUPLICATE_CG_Y_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_HEIGHTS_OF_ALL_AABB_OBJECTS = 0;

//WE HAVE SEEN THAT WE ALWAYS GET THE VERTICAL SPECTRA LINES WHILE RUNNING THE CODE ON 380000 NUMBER OF DIFFERENT WAV FILES RANKING ARE 0 TO 300 IS SUFFICIENT

public int PUBLIC_INT_NON_DUPLICATE_CG_X_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_WIDH_OF_ALL_AABB_OBJECTS = 0;

public int PUBLIC_INT_NON_DUPLICATE_CG_Y_RANKING_FOR_SAAN_STYLES_NORMALIZATION_DONE_ON_GLOBAL_MAX_HEIGHT_OF_ALL_AABB_OBJECTS = 0;

public float WidthMicroseconds;

public float HeightAmplitude;

public float AreaUnderCurve;

public float AreaBoundingBox;

public float AreaProportion;

public List<float> LocalAnglesMilliDegrees = new List<float>();

public int LocalMaximaCount = 0;

public int LocalMinimaCount = 0;

public void ComputeGeometry(int sampleRate)

{

// int sampleCount = EndSampleIndex - StartSampleIndex + 1;

sampleCount = EndSampleIndex - StartSampleIndex + 1;

LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES

= new List<float>();

LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES.Clear();

WidthMicroseconds = (sampleCount * 1000000f) / sampleRate;

/// HeightAmplitude = Math.Max(0.001f, Math.Abs(IsCrest ? MaxAmplitude : MinAmplitude));

///

HeightAmplitude = Math.Max(0.000001f, Math.Abs(IsCrest ? MaxAmplitude : MinAmplitude));

// HeightAmplitude = Math.Max(0.000001f, Math.Abs(IsCrest ? (MaxAmplitude*10000f) : (MinAmplitude*1000f)));

BoundingBox = new RectangleF(0, 0, WidthMicroseconds, HeightAmplitude);

float sumX = 0f, sumY = 0f;

AreaUnderCurve = 0f;

for (int i = 0; i < TipPointsMicrosecondsVsAmplitude.Count; i++)

{

PointF p = TipPointsMicrosecondsVsAmplitude[i];

sumX += p.X;

sumY += p.Y;

//////this.

//////LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES.Add(p.Y / 10000f);//while populating the data in this p.Y we did the multiplications of 10000f times to get the proper calculations of angles

//dont multiply 10000f times heres

this.

LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES.Add(p.Y);//while populating the data in this p.Y we did the multiplications of 10000f times to get the proper calculations of angles

if (i > 0)

{

float dx = TipPointsMicrosecondsVsAmplitude[i].X - TipPointsMicrosecondsVsAmplitude[i - 1].X;

float avgY = (TipPointsMicrosecondsVsAmplitude[i].Y + TipPointsMicrosecondsVsAmplitude[i - 1].Y) / 2f;

AreaUnderCurve += Math.Abs(avgY * dx);

}//if (i > 0)

if (i > 0 && i < TipPointsMicrosecondsVsAmplitude.Count - 1)

{

PointF p1 = TipPointsMicrosecondsVsAmplitude[i - 1];

PointF p2 = TipPointsMicrosecondsVsAmplitude[i];

PointF p3 = TipPointsMicrosecondsVsAmplitude[i + 1];

float dx1 = p2.X - p1.X;

float dy1 = (p2.Y - p1.Y);

float dx2 = p3.X - p2.X;

float dy2 = (p3.Y - p2.Y);

//STRICT NOTE THAT THIS ATAN (USING ARC TAN IS NOT THE PART OF SANJOY NATH'S QHENOMENOLOGY WAVE THEORY)

// THIS USE OF ARC TAN IS FOR REPRESENTATIONS AND REPORTING DATA METRIKS WHICH ARE TO CROSS CHECK THE RESULTS WITH OTHER THEORIES AND TO FIND SOME ADDITIONAL METRIKS FOR THE FUTURE USAGES TO MAKE MORE DETAILED UNDERSTANDING ON THE COMPLEXITIES OF STATISTICAL PROPERTIES FOR OTHER KINDS OF DEEPER INFORMATIONS RETRIEVALS

// IT CAN HAPPEN THAT SOME ADDITIONAL INFORMATIONS ON CREST AABB RECTANGLES AND REOUGH AABB RECTANGLES CAN EXPOSE SEVERAL FEATURES TO MAKE THE WHOLE PHOTON FREE THEORY OF LIGHTS OR TO MAKE QUANTUM MECHANICS ENTIRELY FREE FROM THE WAVE FUUNCTIONS AND TO MAKE SOME FEATURES MORE CALCULATIONS ON THE AABB PROPERTIES TO CONVERT QUEUE OF CRESTTROUGHAABBOBJECTS TO STACK OF CRESTTROUGHAABBOBJECTS WILL EXPOSE DIFFERENT KINDS OF UNDERSTANDING ON THE THEORY OF WAVES

//STRICT NOTE THAT WE ARE NOT USING ANY COS NOR SIN TO ANALYSE WAVE NOR WE ARE USING ANY TRIGONOMETRY FUNCTIONS IN THE SANJOY NATH'S WAVE THEORY NOR WE ARE USING THE TRIGONOMETRY FUNCTIONS TO DESCRIBE THE WAVES OBJECTS

// THE MATHEMATICS OF SANJOY NATH'S QHENOMENOLOGY REASONING SYSTEMS DEAL WITH QUEUE OF OBJECTS AND STACK OF OBJECTS HERE WE ARE USING THE QUEUE OF CRESTTROUGHAABBRECTANGLESOBJECTS AND STACKOFCRESTTROUGHAABBRECTANGLESOBJECTS TO ANALYSE THE WAVR THEORY

float angle1 = (float)Math.Atan2(dy1, dx1);

float angle2 = (float)Math.Atan2(dy2, dx2);

float diff = angle2 - angle1;

float degrees = diff * (180000f / (float)Math.PI);

if (degrees < 0) degrees += 360000f;

LocalAnglesMilliDegrees.Add(degrees);//THESE METRICS WE WILL USE IN FUTURE (NOT YET USED IN CURRENT THEORY OF SANJOY NATH'S QHENOMENOLOGY REASONING OF WAVES)

}//if (i > 0 && i < TipPointsMicrosecondsVsAmplitude.Count - 1)

}//for (int i = 0; i < TipPointsMicrosecondsVsAmplitude.Count; i++)

for (int i = 1; i < TipPointsMicrosecondsVsAmplitude.Count - 1; i++)

{

float prev = TipPointsMicrosecondsVsAmplitude[i - 1].Y;

float curr = TipPointsMicrosecondsVsAmplitude[i].Y;

float next = TipPointsMicrosecondsVsAmplitude[i + 1].Y;

if (curr > prev && curr > next) LocalMaximaCount++;

if (curr < prev && curr < next) LocalMinimaCount++;

}//for (int i = 1; i < TipPointsMicrosecondsVsAmplitude.Count - 1; i++)

AreaBoundingBox = WidthMicroseconds * HeightAmplitude;

AreaProportion = AreaBoundingBox == 0f ? 0f : AreaUnderCurve / AreaBoundingBox;

if (TipPointsMicrosecondsVsAmplitude.Count > 0)

{

CG = new PointF(sumX / TipPointsMicrosecondsVsAmplitude.Count, sumY / TipPointsMicrosecondsVsAmplitude.Count);

}//if (TipPointsMicrosecondsVsAmplitude.Count > 0)

}//public void ComputeGeometry(int sampleRate)

}//public class CrestTroughObject

// TRIED TO MULTIPLY Y WITH 1000 AND THAT CAUSED THE PROBLEMS IN THE BITMAPS

//////public class CrestTroughObject

//////{

////// public int StartSampleIndex;

////// public int EndSampleIndex;

////// public float MaxAmplitude;

////// public float MinAmplitude;

////// public bool IsCrest;

////// public List<PointF> TipPointsMicrosecondsVsAmplitude = new List<PointF>();

////// public RectangleF BoundingBox;

////// public PointF CG;

////// public float WidthMicroseconds;

////// public float HeightAmplitude;

////// public float AreaUnderCurve;

////// public float AreaBoundingBox;

////// public float AreaProportion;

////// public List<float> LocalAnglesMilliDegrees = new List<float>();

////// public int LocalMaximaCount = 0;

////// public int LocalMinimaCount = 0;

////// public void ComputeGeometry(int sampleRate)

////// {

////// int sampleCount = EndSampleIndex - StartSampleIndex + 1;

////// WidthMicroseconds = (sampleCount * 1000000f) / sampleRate;

////// MaxAmplitude *= 1000f;

////// MinAmplitude *= 1000f;

////// HeightAmplitude = Math.Max(0.001f, Math.Abs(IsCrest ? MaxAmplitude : MinAmplitude));

////// BoundingBox = new RectangleF(0, 0, WidthMicroseconds, HeightAmplitude);

////// float sumX = 0f, sumY = 0f;

////// AreaUnderCurve = 0f;

////// for (int i = 0; i < TipPointsMicrosecondsVsAmplitude.Count; i++)

////// {

////// PointF p = TipPointsMicrosecondsVsAmplitude[i];

////// float ampY = p.Y * 1000f;

////// sumX += p.X;

////// sumY += ampY;

////// if (i > 0)

////// {

////// float dx = p.X - TipPointsMicrosecondsVsAmplitude[i - 1].X;

////// float y1 = TipPointsMicrosecondsVsAmplitude[i - 1].Y * 1000f;

////// float avgY = (ampY + y1) / 2f;

////// AreaUnderCurve += Math.Abs(avgY * dx);

////// }// if (i > 0)

////// if (i > 0 && i < TipPointsMicrosecondsVsAmplitude.Count - 1)

////// {

////// float x1 = TipPointsMicrosecondsVsAmplitude[i - 1].X;

////// float y1 = TipPointsMicrosecondsVsAmplitude[i - 1].Y * 1000f;

////// float x2 = p.X;

////// float y2 = ampY;

////// float x3 = TipPointsMicrosecondsVsAmplitude[i + 1].X;

////// float y3 = TipPointsMicrosecondsVsAmplitude[i + 1].Y * 1000f;

////// float dx1 = x2 - x1;

////// float dy1 = y2 - y1;

////// float dx2 = x3 - x2;

////// float dy2 = y3 - y2;

////// float angle1 = (float)Math.Atan2(dy1, dx1);

////// float angle2 = (float)Math.Atan2(dy2, dx2);

////// float diff = angle2 - angle1;

////// float degrees = diff * (180000f / (float)Math.PI);

////// if (degrees < 0) degrees += 360000f;

////// LocalAnglesMilliDegrees.Add(degrees);

////// }//if (i > 0 && i < TipPointsMicrosecondsVsAmplitude.Count - 1)

////// }//for (int i = 0; i < TipPointsMicrosecondsVsAmplitude.Count; i++)

////// for (int i = 1; i < TipPointsMicrosecondsVsAmplitude.Count - 1; i++)

////// {

////// float prev = TipPointsMicrosecondsVsAmplitude[i - 1].Y * 1000f;

////// float curr = TipPointsMicrosecondsVsAmplitude[i].Y * 1000f;

////// float next = TipPointsMicrosecondsVsAmplitude[i + 1].Y * 1000f;

////// if (curr > prev && curr > next) LocalMaximaCount++;

////// if (curr < prev && curr < next) LocalMinimaCount++;

////// }//for (int i = 1; i < TipPointsMicrosecondsVsAmplitude.Count - 1; i++)

////// AreaBoundingBox = WidthMicroseconds * HeightAmplitude;

////// AreaProportion = AreaBoundingBox == 0f ? 0f : AreaUnderCurve / AreaBoundingBox;

////// if (TipPointsMicrosecondsVsAmplitude.Count > 0)

////// CG = new PointF(sumX / TipPointsMicrosecondsVsAmplitude.Count, sumY / TipPointsMicrosecondsVsAmplitude.Count);

////// }

//////}//public class CrestTroughObject

//////public static void OpenAndScanWavFile___WITH_TRANSPARENT_RECTANGLES_OF_TRACING_PAPER_STACKS_BITMAPS_CSV_REPORTS(ref ProgressBar progressBarFOR_ANALYSIS)

//////{

////// OpenFileDialog ofd = new OpenFileDialog();

////// ofd.Filter = "WAV files (*.wav)|*.wav";

////// if (ofd.ShowDialog() != DialogResult.OK) return;

////// string wavPath = ofd.FileName;

////// WavMetadata meta = ReadMetadata(wavPath);

////// if (meta.Channels != 1)

////// {

////// MessageBox.Show("Only mono WAV files are supported.");

////// return;

////// }

////// List<CrestTroughObject> crestTroughs = new List<CrestTroughObject>();

////// int chunkSize = 8192;

////// float maxWidth = 1f, maxHeight = 1f;

////// using (FileStream fs = new FileStream(wavPath, FileMode.Open, FileAccess.Read))

////// using (BinaryReader br = new BinaryReader(fs))

////// {

////// br.ReadBytes(12);

////// while (br.BaseStream.Position < br.BaseStream.Length)

////// {

////// string chunkID = new string(br.ReadChars(4));

////// int chunkSizeBytes = br.ReadInt32();

////// if (chunkID != "data")

////// {

////// br.BaseStream.Position += chunkSizeBytes;

////// continue;

////// }

////// int bytesPerSample = meta.BitsPerSample / 8;

////// int totalSamples = chunkSizeBytes / bytesPerSample;

////// float[] buffer = new float[chunkSize];

////// int samplesRead = 0;

////// CrestTroughObject current = null;

////// bool positive = true;

////// progressBarFOR_ANALYSIS.Minimum = 0;

////// progressBarFOR_ANALYSIS.Maximum = totalSamples;

////// while (samplesRead < totalSamples)

////// {

////// int blockSamples = Math.Min(chunkSize, totalSamples - samplesRead);

////// for (int i = 0; i < blockSamples; i++)

////// {

////// switch (meta.BitsPerSample)

////// {

////// case 8: buffer[i] = (br.ReadByte() - 128) / 128f; break;

////// case 16: buffer[i] = br.ReadInt16() / 32768f; break;

////// case 24:

////// byte[] b = br.ReadBytes(3);

////// int val = (b[2] << 16) | (b[1] << 8) | b[0];

////// if ((val & 0x800000) != 0) val |= unchecked((int)0xFF000000);

////// buffer[i] = val / 8388608f; break;

////// case 32: buffer[i] = br.ReadInt32() / (float)Int32.MaxValue; break;

////// default: MessageBox.Show("Unsupported bit depth."); return;

////// }

////// for (int i = 0; i < blockSamples; i++)

////// {

////// bool currentSign = buffer[i] >= 0;

////// int globalIndex = samplesRead + i;

////// if (current == null)

////// {

////// current = new CrestTroughObject { StartSampleIndex = globalIndex, IsCrest = currentSign };

////// positive = currentSign;

////// }

////// else if (currentSign != positive)

////// {

////// current.EndSampleIndex = globalIndex - 1;

////// int segLen = current.EndSampleIndex - current.StartSampleIndex + 1;

////// if (segLen < 2)

////// {

////// current = new CrestTroughObject { StartSampleIndex = globalIndex, IsCrest = currentSign };

////// positive = currentSign;

////// continue;

////// }

////// float[] seg = new float[segLen];

////// for (int j = 0; j < segLen; j++)

////// {

////// int idx = i - segLen + j;

////// seg[j] = (idx < 0 || idx >= blockSamples) ? 0f : buffer[idx];

////// }

////// current.MaxAmplitude = seg.Max();

////// current.MinAmplitude = seg.Min();

////// float peak = current.IsCrest ? current.MaxAmplitude : current.MinAmplitude;

////// int peakIndex = Array.IndexOf(seg, peak);

////// float xMicro = (peakIndex * 1000000f) / meta.SampleRate;

////// current.TipPointsMicrosecondsVsAmplitude.Add(new PointF(xMicro, peak));

////// current.ComputeGeometry(meta.SampleRate);

////// maxWidth = Math.Max(maxWidth, current.WidthMicroseconds);

////// maxHeight = Math.Max(maxHeight, current.HeightAmplitude);

////// crestTroughs.Add(current);

////// current = new CrestTroughObject { StartSampleIndex = globalIndex, IsCrest = currentSign };

////// positive = currentSign;

////// }

////// samplesRead += blockSamples;

////// progressBarFOR_ANALYSIS.Value = Math.Min(progressBarFOR_ANALYSIS.Maximum, samplesRead);

////// progressBarFOR_ANALYSIS.Refresh();

////// }

////// int MAX_BMP_WIDTH = 10000;

////// int MAX_BMP_HEIGHT = 30000;

////// float widthScale = maxWidth > MAX_BMP_WIDTH ? MAX_BMP_WIDTH / maxWidth : 1f;

////// float heightScale = (crestTroughs.Count * maxHeight) > MAX_BMP_HEIGHT ? MAX_BMP_HEIGHT / (crestTroughs.Count * maxHeight) : 1f;

////// int bmpWidth = Math.Max(32, (int)(maxWidth * widthScale) + 10);

////// int bmpHeight = Math.Max(32, (int)(crestTroughs.Count * maxHeight * heightScale) + 10);

////// try

////// {

////// ExportBitmapWithBoxesAndAxes(crestTroughs, wavPath, widthScale, heightScale, maxWidth, maxHeight, bmpWidth, bmpHeight);

////// ExportDetailedCSV(crestTroughs, wavPath, meta);

////// ExportDxfWithBoxesAndText(crestTroughs, wavPath);

////// ExportCrestTroughGroupingPivot(crestTroughs, wavPath);

////// MessageBox.Show("Complete. Bitmap, CSV, DXF, and pivot reports saved.");

////// }

////// catch (Exception ex)

////// {

////// MessageBox.Show("Report generation failed: " + ex.Message);

////// }

//////}//public static void OpenAndScanWavFile___WITH_TRANSPARENT_RECTANGLES_OF_TRACING_PAPER_STACKS_BITMAPS_CSV_REPORTS(ref ProgressBar progressBarFOR_ANALYSIS)

// RRR

/// <summary>

/// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/// </summary>

//////public class DISCARDING_SINCE_WE_NEED_1000_TIMES_AMPLITUDES___CrestTroughObject

//////{

////// public int StartSampleIndex;

////// public int EndSampleIndex;

////// public float MaxAmplitude;

////// public float MinAmplitude;

////// public bool IsCrest;

////// public List<PointF> TipPointsMicrosecondsVsAmplitude = new List<PointF>();

////// public RectangleF BoundingBox;

////// public PointF CG;

////// public float WidthMicroseconds;

////// public float HeightAmplitude;

////// public float AreaUnderCurve;

////// public float AreaBoundingBox;

////// public float AreaProportion;

////// public List<float> LocalAnglesMilliDegrees = new List<float>();

////// public int LocalMaximaCount = 0;

////// public int LocalMinimaCount = 0;

////// public void ComputeGeometry(int sampleRate)

////// {

////// int sampleCount = EndSampleIndex - StartSampleIndex + 1;

////// WidthMicroseconds = (sampleCount * 1000000f) / sampleRate;

////// HeightAmplitude = Math.Max(0.001f, Math.Abs(IsCrest ? MaxAmplitude : MinAmplitude));

////// BoundingBox = new RectangleF(0, 0, WidthMicroseconds, HeightAmplitude);

////// float sumX = 0f, sumY = 0f;

////// AreaUnderCurve = 0f;

////// for (int i = 0; i < TipPointsMicrosecondsVsAmplitude.Count; i++)

////// {

////// PointF p = TipPointsMicrosecondsVsAmplitude[i];

////// sumX += p.X;

////// sumY += p.Y;

////// if (i > 0)

////// {

////// float dx = TipPointsMicrosecondsVsAmplitude[i].X - TipPointsMicrosecondsVsAmplitude[i - 1].X;

////// float avgY = (TipPointsMicrosecondsVsAmplitude[i].Y + TipPointsMicrosecondsVsAmplitude[i - 1].Y) / 2f;

////// AreaUnderCurve += Math.Abs(avgY * dx);

////// }

////// if (i > 0 && i < TipPointsMicrosecondsVsAmplitude.Count - 1)

////// {

////// PointF p1 = TipPointsMicrosecondsVsAmplitude[i - 1];

////// PointF p2 = TipPointsMicrosecondsVsAmplitude[i];

////// PointF p3 = TipPointsMicrosecondsVsAmplitude[i + 1];

////// float dx1 = p2.X - p1.X;

////// float dy1 = (p2.Y - p1.Y) * 1000f;

////// float dx2 = p3.X - p2.X;

////// float dy2 = (p3.Y - p2.Y) * 1000f;

////// float angle1 = (float)Math.Atan2(dy1, dx1);

////// float angle2 = (float)Math.Atan2(dy2, dx2);

////// float diff = angle2 - angle1;

////// float degrees = diff * (180000f / (float)Math.PI);

////// if (degrees < 0) degrees += 360000f;

////// LocalAnglesMilliDegrees.Add(degrees);

////// }

////// for (int i = 1; i < TipPointsMicrosecondsVsAmplitude.Count - 1; i++)

////// {

////// float prev = TipPointsMicrosecondsVsAmplitude[i - 1].Y;

////// float curr = TipPointsMicrosecondsVsAmplitude[i].Y;

////// float next = TipPointsMicrosecondsVsAmplitude[i + 1].Y;

////// if (curr > prev && curr > next) LocalMaximaCount++;

////// if (curr < prev && curr < next) LocalMinimaCount++;

////// }

////// AreaBoundingBox = WidthMicroseconds * HeightAmplitude;

////// AreaProportion = AreaBoundingBox == 0f ? 0f : AreaUnderCurve / AreaBoundingBox;

////// if (TipPointsMicrosecondsVsAmplitude.Count > 0)

////// CG = new PointF(sumX / TipPointsMicrosecondsVsAmplitude.Count, sumY / TipPointsMicrosecondsVsAmplitude.Count);

////// }// public void ComputeGeometry(int sampleRate)

//////}// public class CrestTroughObject

public static void ExportStatisticsSummary(List<CrestTroughObject> crestTroughs, string wavPath)

{

var groups = new[] {

new { Label = "CREST", Items = crestTroughs.Where(x => x.IsCrest).ToList() },

new { Label = "TROUGH", Items = crestTroughs.Where(x => !x.IsCrest).ToList() }

};

string path = Path.ChangeExtension(wavPath, "_CHARACTERISTICS_STATS.csv");

using (StreamWriter sw = new StreamWriter(path))

{

sw.WriteLine("Group,Feature,Mean,StdDev,Skewness,Kurtosis,Count");

foreach (var grp in groups)

{

string[] features = new[] { "AreaProportion", "HeightAmplitude", "WidthMicroseconds" };

foreach (var feat in features)

{

var values = grp.Items.Select(x =>

feat == "AreaProportion" ? x.AreaProportion :

feat == "HeightAmplitude" ? x.HeightAmplitude :

x.WidthMicroseconds).ToList();

int n = values.Count;

if (n < 2) continue;

float mean = values.Average();

float std = (float)Math.Sqrt(values.Sum(v => (v - mean) * (v - mean)) / (n - 1));

float skew = values.Sum(v => (float)Math.Pow((v - mean) / std, 3)) / n;

float kurt = values.Sum(v => (float)Math.Pow((v - mean) / std, 4)) / n - 3;

sw.WriteLine($"{grp.Label},{feat},{mean:F4},{std:F4},{skew:F4},{kurt:F4},{n}");

}

}// public static void ExportStatisticsSummary(List<CrestTroughObject> crestTroughs, string wavPath)

public static void ExportShortDurationFiltered(List<CrestTroughObject> crestTroughs, string wavPath, int sampleRate)

{

int thresholdSamples = (sampleRate / 1000) * 20;

var filtered = crestTroughs.Where(ct => (ct.EndSampleIndex - ct.StartSampleIndex + 1) < thresholdSamples).ToList();

if (filtered.Count == 0)

{

MessageBox.Show("No short duration crests/troughs (<20ms) found.");

return;

}

string baseName = Path.GetFileNameWithoutExtension(wavPath);

string folder = Path.GetDirectoryName(wavPath);

using (StreamWriter sw = new StreamWriter(Path.Combine(folder, baseName + "_SHORT_FILTERED.csv")))

{

sw.WriteLine("Index,StartSample,EndSample,NumSamples,WidthMicroSec,Height,AreaUnderCurve,AreaProp,IsCrest");

for (int i = 0; i < filtered.Count; i++)

{

var ct = filtered[i];

sw.WriteLine(string.Join(",",

ct.StartSampleIndex,

ct.EndSampleIndex,

ct.EndSampleIndex - ct.StartSampleIndex + 1,

ct.WidthMicroseconds.ToString("F2", CultureInfo.InvariantCulture),

ct.HeightAmplitude.ToString("F4", CultureInfo.InvariantCulture),

ct.AreaUnderCurve.ToString("F2", CultureInfo.InvariantCulture),

ct.AreaProportion.ToString("F4", CultureInfo.InvariantCulture),

ct.IsCrest ? "CREST" : "TROUGH"));

}//for (int i = 0; i < filtered.Count; i++)

}//using (StreamWriter sw = new StreamWriter(Path.Combine(folder, baseName + "_SHORT_FILTERED.csv")))

using (StreamWriter dxf = new StreamWriter(Path.Combine(folder, baseName + "_SHORT_FILTERED.dxf")))

{

}//using (StreamWriter dxf = new StreamWriter(Path.Combine(folder, baseName + "_SHORT_FILTERED.dxf")))

float maxWidth = filtered.Max(ct => ct.WidthMicroseconds);

// float maxHeight = filtered.Max(ct => Math.Abs(ct.CG.Y));

float maxHeight = filtered.Max(ct => Math.Abs(ct.CG.Y/10f));// i have accumulated the data 10000f times while populating the amplitudes

float widthScale = maxWidth > 1000 ? 1000f / maxWidth : 1f;

float heightScale = maxHeight > 1f ? 100f / maxHeight : 1f;

int bmpWidth = Math.Max(64, (int)(maxWidth * widthScale) + 10);

int bmpHeight = Math.Max(64, (int)(filtered.Count * maxHeight * heightScale) + 10);

//////float maxWidth = Math.Max(1f, filtered.Max(ct => ct.WidthMicroseconds));

//////float maxHeight = Math.Max(1f, filtered.Max(ct => Math.Abs(ct.CG.Y)));

//////float widthScale = maxWidth > 1000f ? 1000f / maxWidth : 1f;

//////float heightScale = maxHeight > 1f ? 100f / maxHeight : 1f;

//////int bmpWidth = Math.Max(64, (int)(maxWidth * widthScale) + 10);

//////int bmpHeight = Math.Max(64, (int)(filtered.Count * maxHeight * heightScale) + 10);

try

{

using (Bitmap bmp = new Bitmap(bmpWidth, bmpHeight))

{

using (Graphics g = Graphics.FromImage(bmp))

{

g.Clear(Color.White);

for (int i = 0; i < filtered.Count; i++)

{

var ct = filtered[i];

float cx = ct.CG.X * widthScale;

float cy = ct.IsCrest

? (i * maxHeight * heightScale + (maxHeight * heightScale - ct.CG.Y * heightScale))

: (i * maxHeight * heightScale + (maxHeight * heightScale + Math.Abs(ct.CG.Y) * heightScale));

int radius = Math.Max(2, (ct.EndSampleIndex - ct.StartSampleIndex) / 128);

Brush b = ct.IsCrest ? Brushes.Blue : Brushes.Red;

g.FillEllipse(b, cx - radius, cy - radius, radius * 2, radius * 2);

g.DrawString($"#{i}", SystemFonts.DefaultFont, Brushes.Black, cx + 4, cy + 4);

}

if (bmpWidth <= 0 || bmpHeight <= 0)

{

MessageBox.Show("Invalid bitmap dimensions. Aborting image save.");

return;

}//if (bmpWidth <= 0 || bmpHeight <= 0)

bmp.Save(Path.Combine(folder, baseName + "_SHORT_FILTERED.bmp"));

}// using (Bitmap bmp = new Bitmap(bmpWidth, bmpHeight))

}

catch (Exception ___excp_to_save_bitmaps_short_filtered)

{

System.Windows.Forms.MessageBox.Show("___excp_to_save_bitmaps_short_filtered = " + ___excp_to_save_bitmaps_short_filtered.Message + " " + ___excp_to_save_bitmaps_short_filtered.StackTrace.ToString() + " bmpWidth = " + bmpWidth + " bmpHeight = " + bmpHeight);

Console.WriteLine("___excp_to_save_bitmaps_short_filtered = " + ___excp_to_save_bitmaps_short_filtered.Message + " " + ___excp_to_save_bitmaps_short_filtered.StackTrace.ToString() + " bmpWidth = " + bmpWidth + " bmpHeight = " + bmpHeight);

}//catch(Exception ___excp_to_save_bitmaps_short_filtered)

}//public static void ExportShortDurationFiltered(List<CrestTroughObject> crestTroughs, string wavPath, int sampleRate)

//////public static void ExportShortDurationFiltered(List<CrestTroughObject> crestTroughs, string wavPath, int sampleRate)

//////{

////// int thresholdSamples = (sampleRate / 1000) * 20;

////// var filtered = crestTroughs.Where(ct => (ct.EndSampleIndex - ct.StartSampleIndex + 1) < thresholdSamples).ToList();

////// if (filtered.Count == 0)

////// {

////// MessageBox.Show("No short duration crests/troughs (<20ms) found.");

////// return;

////// }

////// string baseName = Path.GetFileNameWithoutExtension(wavPath);

////// string folder = Path.GetDirectoryName(wavPath);

////// using (StreamWriter sw = new StreamWriter(Path.Combine(folder, baseName + "_SHORT_FILTERED.csv")))

////// {

////// sw.WriteLine("Index,StartSample,EndSample,NumSamples,WidthMicroSec,Height,AreaUnderCurve,AreaProp,IsCrest");

////// for (int i = 0; i < filtered.Count; i++)

////// {

////// var ct = filtered[i];

////// sw.WriteLine(string.Join(",",

////// i,

////// ct.StartSampleIndex,

////// ct.EndSampleIndex,

////// ct.EndSampleIndex - ct.StartSampleIndex + 1,

////// ct.WidthMicroseconds.ToString("F2", CultureInfo.InvariantCulture),

////// ct.HeightAmplitude.ToString("F4", CultureInfo.InvariantCulture),

////// ct.AreaUnderCurve.ToString("F2", CultureInfo.InvariantCulture),

////// ct.AreaProportion.ToString("F4", CultureInfo.InvariantCulture),

////// ct.IsCrest ? "CREST" : "TROUGH"));

////// }

////// using (StreamWriter dxf = new StreamWriter(Path.Combine(folder, baseName + "_SHORT_FILTERED.dxf")))

////// {

////// CrestTroughAnalyzer___WITH_TRANSPARENT_RECTANGLES_OF_TRACING_PAPER_STACKS_BITMAPS_CSV_REPORTS.ExportDxfWithBoxesAndText(filtered, wavPath);

////// }

////// int bmpWidth = 1000;

////// int bmpHeight = Math.Max(64, 200 + 30 * filtered.Count);

////// using (Bitmap bmp = new Bitmap(bmpWidth, bmpHeight))

////// {

////// using (Graphics g = Graphics.FromImage(bmp))

////// {

////// g.Clear(Color.White);

////// for (int i = 0; i < filtered.Count; i++)

////// {

////// var ct = filtered[i];

////// float cx = ct.CG.X / 100f;

////// float cy = ct.IsCrest ? 100 - (ct.CG.Y) : 100 + (Math.Abs(ct.CG.Y));

////// int radius = Math.Max(2, (ct.EndSampleIndex - ct.StartSampleIndex) / 128);

////// Brush b = ct.IsCrest ? Brushes.Blue : Brushes.Red;

////// g.FillEllipse(b, cx - radius, cy - radius, radius * 2, radius * 2);

////// g.DrawString($"#{i}", SystemFonts.DefaultFont, Brushes.Black, cx + 4, cy + 4);

////// }

////// bmp.Save(Path.Combine(folder, baseName + "_SHORT_FILTERED.bmp"));

////// }

//////}//public static void ExportShortDurationFiltered(List<CrestTroughObject> crestTroughs, string wavPath, int sampleRate)

//////public static void ExportShortDurationFiltered(List<CrestTroughObject> crestTroughs, string wavPath, int sampleRate)

//////{

////// int thresholdSamples = (sampleRate / 1000) * 20;

////// var filtered = crestTroughs.Where(ct => (ct.EndSampleIndex - ct.StartSampleIndex + 1) < thresholdSamples).ToList();

////// string baseName = Path.GetFileNameWithoutExtension(wavPath);

////// string folder = Path.GetDirectoryName(wavPath);

////// using (StreamWriter sw = new StreamWriter(Path.Combine(folder, baseName + "_SHORT_FILTERED.csv")))

////// {

////// sw.WriteLine("Index,StartSample,EndSample,NumSamples,WidthMicroSec,Height,AreaUnderCurve,AreaProp,IsCrest");

////// for (int i = 0; i < filtered.Count; i++)

////// {

////// var ct = filtered[i];

////// sw.WriteLine(string.Join(",",

////// i,

////// ct.StartSampleIndex,

////// ct.EndSampleIndex,

////// ct.EndSampleIndex - ct.StartSampleIndex + 1,

////// ct.WidthMicroseconds.ToString("F2", CultureInfo.InvariantCulture),

////// ct.HeightAmplitude.ToString("F4", CultureInfo.InvariantCulture),

////// ct.AreaUnderCurve.ToString("F2", CultureInfo.InvariantCulture),

////// ct.AreaProportion.ToString("F4", CultureInfo.InvariantCulture),

////// ct.IsCrest ? "CREST" : "TROUGH"));

////// }

////// using (StreamWriter dxf = new StreamWriter(Path.Combine(folder, baseName + "_SHORT_FILTERED.dxf")))

////// {

////// AddDxfDecorations(dxf, filtered, wavPath);

////// }

////// using (Bitmap bmp = new Bitmap(1000, 200 + 30 * filtered.Count))

////// {

////// using (Graphics g = Graphics.FromImage(bmp))

////// {

////// g.Clear(Color.White);

////// for (int i = 0; i < filtered.Count; i++)

////// {

////// var ct = filtered[i];

////// float cx = ct.CG.X / 100f;

////// float cy = ct.IsCrest ? 100 - (ct.CG.Y * 1000) : 100 + (Math.Abs(ct.CG.Y) * 1000);

////// int radius = Math.Max(2, (ct.EndSampleIndex - ct.StartSampleIndex) / 128);

////// Brush b = ct.IsCrest ? Brushes.Blue : Brushes.Red;

////// g.FillEllipse(b, cx - radius, cy - radius, radius * 2, radius * 2);

////// g.DrawString($"#{i}", SystemFonts.DefaultFont, Brushes.Black, cx + 4, cy + 4);

////// }

////// bmp.Save(Path.Combine(folder, baseName + "_SHORT_FILTERED.bmp"));

////// }

//////}//public static void ExportShortDurationFiltered(List<CrestTroughObject> crestTroughs, string wavPath, int sampleRate)

// Full method: OpenAndScanWavFile___WITH_TRANSPARENT_RECTANGLES_...

// Including WAV reading, crest/trough extraction, geometry calculation, bitmap + CSV + DXF export

// Enhancements: zero-line alignment, bounding boxes, CG markers, filename labels, area proportions, local angles, statistical grouping

// This is a full replacement of the method and related helpers for direct copy-paste

// === DECLARATION START ===

public static void OpenAndScanWavFile___WITH_TRANSPARENT_RECTANGLES_OF_TRACING_PAPER_STACKS_BITMAPS_CSV_REPORTS(ref ProgressBar progressBarFOR_ANALYSIS)

{

OpenFileDialog ofd = new OpenFileDialog();

ofd.Filter = "WAV files (*.wav)|*.wav";

if (ofd.ShowDialog() != DialogResult.OK) return;

double ___temp_double_zero_crossing_counter = 0;

double ___temp_double_crest_counter = 0;

double ___temp_double_trough_counter = 0;

string wavPath = ofd.FileName;

WavMetadata meta = ReadMetadata(wavPath);

if (meta.Channels != 1) { MessageBox.Show("Only mono WAV files are supported."); return; }

List<CrestTroughObject> crestTroughs = new List<CrestTroughObject>();

int chunkSize = 8192;

float maxWidth = 1f, maxHeight = 1f;

// TO AVOID THE NULL REFERENCE EXCEPTION WE WILL POPULATE THIS WITH DUMMY LIST

// CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

//SANJOY NATH HAS SEEN THAT IN 380000 WAV FILES ANALYSIS THAT NON DUPLICATE X OF CG ARE <=600 IN COUNTS OF NON DUPLICATE X OF CG FOUND THAT IS NOT MORE THAN

//CALLING CONVENTION IS LIKE THIS

//////.PUBLIC_STATIC_ARRAY_OF_LISTS_OF_CrestTroughObject___WITH_SORTED_SMALLEST_TO_LARGEST_NON_DUPLICATE_SAAN_STYLES_SCALED_NORMALIZED_SCALED_X___0_TO_600_UNIQUE_RANKS_OF_SORTED_NORMALIZED_X_OF_CG

.PUBLIC_STATIC_ARRAY_OF_LISTS_OF_CrestTroughObject___WITH_SORTED_SMALLEST_TO_LARGEST_NON_DUPLICATE_SAAN_STYLES_SCALED_NORMALIZED_SCALED_X___0_TO_600_UNIQUE_RANKS_OF_SORTED_NORMALIZED_X_OF_CG

= new List<CrestTroughObject>[600];//0 rank to 600 rank is sufficient

for(int rrr_populator=0;rrr_populator<600;rrr_populator++)

{

//AFTER ALL THE CREST TROUGH OBJECTS ARE POPULATED WE WILL SORT THE RESCAN THE WHOLE LIST OF CREST TROUGH OBJECTS WITH SAAN STYLES NORMALIZED SCALED X OF CG OF EACH CREST TROUGHS AND THEN WE WILL RANK THESE CREST TROUGHS VERTICAL STRIPS AS PER X OBJECTS

// AFTER TESTING ON 380000 DIFFERENT KINDS OF WAVE FILES SANJOY NATH HAS SEEN THERE ARE <600 NUMBERS OF CRISP SHARP VERTICAL LINES SPECTRAL LINES FORMS WHEN THE LEFT MARGINS OF ALL KINDS OF CREST TROUGH AABB RECTANGLES ARE DONE THE CG OF THE CREST TROUGH BOXES FORMS SHARP VERTICAL LINES AT DIFFERENT DISTINCT X DATA WHICH ARE CORRESPONDING THE FREQUENCY SPECTRA LIKE THINGS

// THE DIFFERENT SIZES OF WIDTHS OF AABB OBJECTS ARE DUE TO DIFFERENT FREQUENCIES (THOUGH SANJOY NATH'S QHENOMENOLOGY WAVE THEORY DONT USE THE TERMS LIKE FREQUENCY NOR USE THE TERMS LIKE WAVE LENGTHS BUT THESE VERTICAL SPECTRA OF X OF CG OF CRESTTROUGH AABB RECTANGLES) SUPPLY THE INFORMATIONS REGARDING THE FREQUENCY (OF THE CONVENTIONAL WAVE THEORY NO USE OF FFT NO USE OF COS NO USE OF SIN NO USE OF FOURIER ARE THERE TO GENERATE THESE SPECTRAL LINES)

//SANJOY NATH WANTS TO DO THE CROSS VERIFY THE SOUNDS OF THE REGENERATED WAV FILES DIFFERENT 600 WAV FILES ARE TO CONSTRUCT WHICH ARE ALL OF SAME SAMPLE SIZE AS ACTUAL IMPORTED WAVE FILE BUT ALL OTHER AMPLITUDES SILENCED ONLY THESE RANK WISE SAMPLES REPOPILATED FROM THE CRESTTROUGH OBJECTS DATA RANK WISE

// TO RE RENDER THE CROSS VERIFICATIONS OF THE RANK WISE OUTPUTS Every CrestTrooughObject has preserved LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES simply to cross verify the conditions of the outputs filtering efficiency working properly or not

// these preserved LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES is not part of theory but this LIST_OF_ALL_ACTUAL_FLOATING_VALUES_OF_SAMPLES_AMPLITUDES is to verify the theory and to report the comparing of regenerated wave files following the same kind of output as per conventional wave theories or not

.PUBLIC_STATIC_ARRAY_OF_LISTS_OF_CrestTroughObject___WITH_SORTED_SMALLEST_TO_LARGEST_NON_DUPLICATE_SAAN_STYLES_SCALED_NORMALIZED_SCALED_X___0_TO_600_UNIQUE_RANKS_OF_SORTED_NORMALIZED_X_OF_CG

[rrr_populator]

new List<CrestTroughObject>();

.PUBLIC_STATIC_ARRAY_OF_LISTS_OF_CrestTroughObject___WITH_SORTED_SMALLEST_TO_LARGEST_NON_DUPLICATE_SAAN_STYLES_SCALED_NORMALIZED_SCALED_X___0_TO_600_UNIQUE_RANKS_OF_SORTED_NORMALIZED_X_OF_CG

[rrr_populator]

.Clear();

// this will avoid the null reference exceptions

}//for(int rrr_populator=0;rrr_populator<600;rrr_populator++)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

using (FileStream fs = new FileStream(wavPath, FileMode.Open, FileAccess.Read))

{

using (BinaryReader br = new BinaryReader(fs))

{

br.ReadBytes(12);

while (br.BaseStream.Position < br.BaseStream.Length)

{

string chunkID = new string(br.ReadChars(4));

int chunkSizeBytes = br.ReadInt32();

if (chunkID != "data")

{

br.BaseStream.Position += chunkSizeBytes; continue;

}// if (chunkID != "data")

int bytesPerSample = meta.BitsPerSample / 8;

int totalSamples = chunkSizeBytes / bytesPerSample;

float[] buffer = new float[chunkSize];

int samplesRead = 0;

CrestTroughObject current = null;

bool positive = true;

progressBarFOR_ANALYSIS.Minimum = 0;

progressBarFOR_ANALYSIS.Maximum = totalSamples;

while (samplesRead < totalSamples)

{

int blockSamples = Math.Min(chunkSize, totalSamples - samplesRead);

for (int i = 0; i < blockSamples; i++)

{

switch (meta.BitsPerSample)

{

case 8: buffer[i] = (br.ReadByte() - 128) / 128f; break;

case 16: buffer[i] = br.ReadInt16() / 32768f; break;

case 24:

byte[] b = br.ReadBytes(3);

int val = (b[2] << 16) | (b[1] << 8) | b[0];

if ((val & 0x800000) != 0) val |= unchecked((int)0xFF000000);

buffer[i] = val / 8388608f; break;

case 32: buffer[i] = br.ReadInt32() / (float)Int32.MaxValue; break;

default: MessageBox.Show("Unsupported bit depth."); return;

}//switch (meta.BitsPerSample)

}//for (int i = 0; i < blockSamples; i++)

for (int i = 0; i < blockSamples; i++)

{

bool currentSign = buffer[i] >= 0;

int globalIndex = samplesRead + i;

if (current == null)

{

current = new CrestTroughObject { StartSampleIndex = globalIndex, IsCrest = currentSign };

positive = currentSign;

}//if (current == null)

else if (currentSign != positive)

{

current.EndSampleIndex = globalIndex - 1;

int segLen = current.EndSampleIndex - current.StartSampleIndex + 1;

if (segLen < 2)

{

current = new CrestTroughObject { StartSampleIndex = globalIndex, IsCrest = currentSign }; positive = currentSign; continue;

}//if (segLen < 2)

float[] seg = new float[segLen];

for (int j = 0; j < segLen; j++)

{

int idx = i - segLen + j;

//seg[j] = (idx < 0 || idx >= blockSamples) ? 0f : buffer[idx];

seg[j] = (idx < 0 || idx >= blockSamples) ? 0f : buffer[idx];

}//for (int j = 0; j < segLen; j++)

//saan stopped it here current.MaxAmplitude = seg.Max();

//saan stopped it here current.MinAmplitude = seg.Min();

//all segment data populated

current.MaxAmplitude = seg.Max();//saan brought it here

current.MinAmplitude = seg.Min();//saan brought it here

for (int j = 0; j < segLen; j++)

{

// RRR

float timeMicro = (j * 1000000f) / meta.SampleRate;

// current.TipPointsMicrosecondsVsAmplitude.Add(new PointF(timeMicro, seg[j]));

current.TipPointsMicrosecondsVsAmplitude.Add(new PointF(timeMicro, seg[j] * 10000f));//saan did * 10000f to get better angles calcs

//////////CALLING CONVENTIONS

//////////CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

////////public static double PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES = 0;

////////public static double PUBLIC_STATIC_DOUBLE_AVERAGE_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES = 0;

PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

+ (double)(seg[j] * 10000f);

}//for (int j = 0; j < segLen; j++)

//////current.MaxAmplitude = seg.Max();//saan brought it here

//////current.MinAmplitude = seg.Min();//saan brought it here

//////////////////////////////////////////////////////// CALLED ONLY ONCE ////////////////////////

current.ComputeGeometry(meta.SampleRate);

//////////////////////////////////////////////////////// CALLED ONLY ONCE ////////////////////////

maxWidth = Math.Max(maxWidth, current.WidthMicroseconds);

maxHeight = Math.Max(maxHeight, current.HeightAmplitude);

___temp_double_zero_crossing_counter ++;

current

.OVERALL_AABB_COUNTER_EITHER_IT_IS_CREST_OR_IT_IS_TROUGH____COUNTER_TO_RECONSTRUCTION_THE_ACTUAL_QUEUE_STRUCTURE_FROM_THE_STACK_ANALYSIS_DATA

= ___temp_double_zero_crossing_counter;

if(currentSign)

{

___temp_double_crest_counter ++;

current.CREST_COUNTER

___temp_double_crest_counter;

}//if(currentSign)

else

{

___temp_double_trough_counter++;

current

.TROUGH_COUNTER

___temp_double_trough_counter;

}// end of else of if(currentSign)

crestTroughs.Add(current);

current = new CrestTroughObject { StartSampleIndex = globalIndex, IsCrest = currentSign };

positive = currentSign;

//done in open and scan wav files

////////CrestTroughAnalyzer___WITH_TRANSPARENT_RECTANGLES_OF_TRACING_PAPER_STACKS_BITMAPS_CSV_REPORTS.

//////public static double PUBLIC_STATIC_DOUBLE_MIN_WIDTH_MIKROSEC_FOUND_IN_CRESTS = +600000000;

//////public static double PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_CRESTS = -600000000;

//////public static double PUBLIC_STATIC_DOUBLE_MIN_WIDTH_MIKROSEC_FOUND_IN_TROUGHS = +600000000;

//////public static double PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_TROUGHS = -600000000;

//////public static double PUBLIC_STATIC_DOUBLE_MIN_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS = +600000000;

//////public static double PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS = -600000000;

//////public static double PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUND_IN_CRESTS = -600000000;

//////public static double PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUND_IN_TROUGHS = -600000000;

//////public static double PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUNDOVERALL_IN_CRESTS_AND_TROUGHS = -600000000;

.PUBLIC_STATIC_DOUBLE_MIN_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS

Math.Min

(

.PUBLIC_STATIC_DOUBLE_MIN_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS

(double) maxWidth

);

.PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS

Math.Max

(

.PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS

(double)maxWidth

);

///////////////////////////////////////////////////////////////////////////////////////////////////////

.PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUNDOVERALL_IN_CRESTS_AND_TROUGHS

Math.Max

(

.PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUNDOVERALL_IN_CRESTS_AND_TROUGHS

(double)maxHeight

);

///////////////////////////////////////////////////////////////////////////////////////////////////////

}//else if (currentSign != positive)

}//for (int i = 0; i < blockSamples; i++)

samplesRead += blockSamples;

.PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE

// += samplesRead;

= samplesRead;// globalIndex;

//////////CALLING CONVENTIONS

////////public static double PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES = 0;

////////public static double PUBLIC_STATIC_DOUBLE_AVERAGE_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES = 0;

//////.

//////PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

//////=

//////.

//////PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

//////+ (double)(seg[j] * 10000f);

/////////////////////////////////////////////////////////////////////////

.PUBLIC_STATIC_FLOAT_ARRAY____RAW_SAMPLES_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES

= new float

[

.PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE

];

//////////////////////////////////////////////////////////////////////

///

Array.Clear

(

.PUBLIC_STATIC_FLOAT_ARRAY____RAW_SAMPLES_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES

, 0,

.PUBLIC_STATIC_FLOAT_ARRAY____RAW_SAMPLES_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES.Length

);

/////////////////////////////////////////////////////////////////////////

.PUBLIC_STATIC_FLOAT_ARRAY____RECONSTRUCTED_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES

= new float

[

.PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE

];

//////////////////////////////////////////////////////////////////////

///

//for safe sides

Array.Clear

(

.PUBLIC_STATIC_FLOAT_ARRAY____RECONSTRUCTED_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES

, 0,

.PUBLIC_STATIC_FLOAT_ARRAY____RECONSTRUCTED_FLOATING_ARRAY_OF_WHOLE_FILES_ZERO_LINES_SHIFTED_TO_AVERAGES

.Length

);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

.PUBLIC_STATIC_DOUBLE_AVERAGE_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

.PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

Math.Max

(

.PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE

);

/////////////////////////////////////////////////////////////////////////////////////////////

///

// not here it disturbs

////////System.Windows.Forms.MessageBox.Show

//////// (

//////// "Total Of All Amplitudes = "+

//////// CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

//////// .PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

//////// +"\r\n"+

//////// "Total Samples Count = " +

//////// CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

//////// .PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE

//////// +"\r\n" +

//////// "Average Amplitude overall in whole file (10000 times) = "

//////// +

//////// CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

//////// .PUBLIC_STATIC_DOUBLE_AVERAGE_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

//////// );

progressBarFOR_ANALYSIS.Value = Math.Min(progressBarFOR_ANALYSIS.Maximum, samplesRead);

progressBarFOR_ANALYSIS.Invalidate();

progressBarFOR_ANALYSIS.Refresh();

}//while (samplesRead < totalSamples)

// ALL SAMPLES READING COMPLETES

}//while (samplesRead < totalSamples)

}//using (BinaryReader br = new BinaryReader(fs))

}//using (FileStream fs = new FileStream(wavPath, FileMode.Open, FileAccess.Read))

progressBarFOR_ANALYSIS.Value = Math.Min(progressBarFOR_ANALYSIS.Maximum, progressBarFOR_ANALYSIS.Maximum);

progressBarFOR_ANALYSIS.Invalidate();

progressBarFOR_ANALYSIS.Refresh();

System.Windows.Forms.MessageBox.Show("THE FILES READING PART COMPLETES THE SAMPLES DATA ALL READING DONES");

System.Windows.Forms.MessageBox.Show

(

"Total Of All Amplitudes = " +

.PUBLIC_STATIC_DOUBLE_SUM_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

+ "\r\n" +

"Total Samples Count = " +

.PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE

+ "\r\n" +

"Average Amplitude overall in whole file (10000 times) = "

.PUBLIC_STATIC_DOUBLE_AVERAGE_OF_ALL_SAMPLES_AMPLITUDES_IN_THE_WHOLE_WAV_FILE___10000_TIMES

);

int MAX_BMP_WIDTH = 10000;

int MAX_BMP_HEIGHT = 30000;

float widthScale = maxWidth > MAX_BMP_WIDTH ? MAX_BMP_WIDTH / maxWidth : 1f;

float heightScale = (crestTroughs.Count * maxHeight) > MAX_BMP_HEIGHT ? MAX_BMP_HEIGHT / (crestTroughs.Count * maxHeight) : 1f;

// float heightScale = ( maxHeight) > MAX_BMP_HEIGHT ? MAX_BMP_HEIGHT / ( maxHeight) : 1f;

int bmpWidth = Math.Max(32, (int)(maxWidth * widthScale) + 10);

int bmpHeight = Math.Max(32, (int)(crestTroughs.Count * maxHeight * heightScale) + 10);

// int bmpHeight = Math.Max(32, (int)((1+1)*10000f * maxHeight * heightScale) + 10);

ExportBitmapWithBoxesAndAxes(crestTroughs, wavPath, widthScale, heightScale, maxWidth, maxHeight, bmpWidth, bmpHeight);

ExportCrestTroughGroupingPivot(crestTroughs, wavPath);

ExportDetailedCSV(crestTroughs, wavPath, meta);

// THIS HAS THE ExportDxfWithBoxesAndText_UNSCALED_CG_LEFTSALIGNED_AABB_GRAPH_CG_SHOWS_VERTS_SPECTRAS

ExportDxfWithBoxesAndText_UNSCALED_CG_LEFTSALIGNED_AABB_GRAPH_CG_SHOWS_VERTS_SPECTRAS(crestTroughs, wavPath);

/////////SPECIAL DXF

ExportDxf_With_SAAN_STYLES_SINGLE_OUTER_GRAPH_SAANS_NORMALIZED_SCALED_TO_MAX_WIDTH_CG_X_DATABoxesAndText(crestTroughs, wavPath);

///////////////////tooooo important to call this before ranked wav files generations//////////////////////////

CALL_THIS_BEFORE_GENERATING___RANKED_WAV_FILES___ExportDxf_With_CREST_TROUGH_COUNTER_AS_Y_VALUES___SAAN_STYLES_SINGLE_OUTER_GRAPH_SAANS_NORMALIZED_SCALED_TO_MAX_WIDTH_CG_X_DATABoxesAndText(crestTroughs, wavPath);

///////////////////tooooo important to call this before ranked wav files generations//////////////////////////

//THIS DOES THE FREQUENCY DETECTIONS ALSO BT FINDERS ENVELLOPING ALSO MIDI NOTES GENERATIONS ALSO

SAVE_6_DIFFERENT_ZERO_LINE_SHIFTED_WAV_FILES_WITH_SIGNED_AVERAGES_AND_STANDARD_DEVIATIONS___AFTER_SAAN_NORMALIZED_DXF_GENERATIONS_COMPLETES(wavPath);

// TO CHECK THE POSSIBILITY OF COMBINATORIAL CLUBBABILITY FOR CONTINUOUS CREST TROUGH NUMBERING AND RANKS STATUS

GenerateRankedSpectralCSVReport(crestTroughs, wavPath);

// public static List<double> DetectBeats(float[] samples, int sampleRate, double thresholdPercent = 0.65)

System.Windows.Forms.MessageBox.Show("Completed the populations of proportioned x of cg CALL_THIS_BEFORE_GENERATING___RANKED_WAV_FILES___ExportDxf_With_CREST_TROUGH_COUNTER_AS_Y_VALUES___SAAN_STYLES_SINGLE_OUTER_GRAPH_SAANS_NORMALIZED_SCALED_TO_MAX_WIDTH_CG_X_DATABoxesAndText\r\n\r\n\r\nNOW WE WILL GENERATE RANKED WAV FILES SPECTRUMS VERTICAL LINES X RANK WISE");

GenerateRankedSpectralWavFiles______DONT_CALL_THIS_BEFORE_ALL_DXF_PREPARED_SINCE_DXF_GENERATORS_POPULATE_SCALED_CG_X_DATA

(

crestTroughs,

.PUBLIC_STATIC_INT_TOTAL_NUMBER_OF_SAMPLES_IN_THIS_FILE

meta.SampleRate,

// string outputFolder

wavPath

);

// ExportDetailedCSV(crestTroughs, wavPath, meta);

// ExportBitmapWithBoxesAndAxes(crestTroughs, wavPath, widthScale, heightScale, maxWidth, maxHeight, bmpWidth, bmpHeight);

// ExportCrestTroughGroupingPivot(crestTroughs, wavPath);

// ExportShortDurationFiltered(crestTroughs, wavPath, meta);

ExportShortDurationFiltered(crestTroughs, wavPath, meta.SampleRate);

ExportStatisticsSummary(crestTroughs, wavPath);

// ExportDxfWithBoxesAndCenterlines(crestTroughs, wavPath, meta);

// ExportStatisticsSummary(crestTroughs, wavPath);

// ExportShortDurationFiltered(crestTroughs, wavPath, meta);

MessageBox.Show("Complete. Bitmap, CSV, DXF, and pivot reports saved.");

}//public static void OpenAndScanWavFile___WITH_TRANSPARENT_RECTANGLES_OF_TRACING_PAPER_STACKS_BITMAPS_CSV_REPORTS(ref ProgressBar progressBarFOR_ANALYSIS)

//ExportDxfWithBoxesAndText

// ExportDetailedCSV

public static void ExportDetailedCSV(List<CrestTroughObject> crestTroughs, string wavPath, WavMetadata meta)

{

using (StreamWriter sw = new StreamWriter(Path.ChangeExtension(wavPath, "_DETAILED_STATS.csv")))

{

sw.WriteLine("Index,StartSample,EndSample,NumSamples,WidthMicroSec,Height,CG_X,CG_Y,AreaUnderCurve,AreaBox,AreaRatio,MaximaCount,MinimaCount,IsCrest,Angles");

for (int i = 0; i < crestTroughs.Count; i++)

{

var ct = crestTroughs[i];

string angles = string.Join("|", ct.LocalAnglesMilliDegrees.Select(a => a.ToString("F1", CultureInfo.InvariantCulture)));

sw.WriteLine(string.Join(",",

ct.StartSampleIndex,

ct.EndSampleIndex,

(ct.EndSampleIndex - ct.StartSampleIndex + 1),

ct.WidthMicroseconds.ToString("F1", CultureInfo.InvariantCulture),

ct.HeightAmplitude.ToString("F6", CultureInfo.InvariantCulture),

ct.CG.X.ToString("F1", CultureInfo.InvariantCulture),

ct.CG.Y.ToString("F6", CultureInfo.InvariantCulture),

ct.AreaUnderCurve.ToString("F1", CultureInfo.InvariantCulture),

ct.AreaBoundingBox.ToString("F1", CultureInfo.InvariantCulture),

ct.AreaProportion.ToString("F3", CultureInfo.InvariantCulture),

ct.LocalMaximaCount,

ct.LocalMinimaCount,

ct.IsCrest ? "CREST" : "TROUGH",

angles));

}//for (int i = 0; i < crestTroughs.Count; i++)

}

}//public static void ExportDetailedCSV(List<CrestTroughObject> crestTroughs, string wavPath, WavMetadata meta)

//////public static void ExportDxfWithBoxesAndText(List<CrestTroughObject> crestTroughs, string wavPath)

//////{

////// string path = Path.ChangeExtension(wavPath, "_GRAPH_CG_BOXES_AXES.dxf");

////// using (StreamWriter sw = new StreamWriter(path))

////// {

////// sw.WriteLine("0\nSECTION\n2\nENTITIES");

////// foreach (var ct in crestTroughs)

////// {

////// float cx = ct.CG.X;

////// float cy = ct.IsCrest ? ct.CG.Y : -Math.Abs(ct.CG.Y);

////// float radius = Math.Max(1f, (ct.EndSampleIndex - ct.StartSampleIndex) / 10f);

////// int color = ct.IsCrest ? 5 : 1;

////// sw.WriteLine($"0\nCIRCLE\n8\n0\n62\n{color}\n10\n{cx.ToString("F3", CultureInfo.InvariantCulture)}\n20\n{cy.ToString("F3", CultureInfo.InvariantCulture)}\n30\n0\n40\n{radius.ToString("F3", CultureInfo.InvariantCulture)}");

////// float x1 = cx - ct.BoundingBox.Width / 2;

////// float x2 = cx + ct.BoundingBox.Width / 2;

////// float y1 = ct.IsCrest ? 0 : -ct.BoundingBox.Height;

////// float y2 = ct.IsCrest ? ct.BoundingBox.Height : 0;

////// sw.WriteLine($"0\nLINE\n8\n0\n62\n{color}\n10\n{x1.ToString("F3", CultureInfo.InvariantCulture)}\n20\n{y1.ToString("F3", CultureInfo.InvariantCulture)}\n30\n0\n11\n{x2.ToString("F3", CultureInfo.InvariantCulture)}\n21\n{y2.ToString("F3", CultureInfo.InvariantCulture)}\n31\n0");

////// }// foreach (var ct in crestTroughs)

////// sw.WriteLine("0\nENDSEC\n0\nEOF");

////// }// using (StreamWriter sw = new StreamWriter(path))

//////}//public static void ExportDxfWithBoxesAndText(List<CrestTroughObject> crestTroughs, string wavPath)

public static void ExportDxf_With_SAAN_STYLES_SINGLE_OUTER_GRAPH_SAANS_NORMALIZED_SCALED_TO_MAX_WIDTH_CG_X_DATABoxesAndText(List<CrestTroughObject> crestTroughs, string wavPath)

{

string path = Path.ChangeExtension(wavPath, "_GRAPH_SAANS_NORMALIZED_SCALED_TO_MAX_WIDTH_CG_X_DATA.dxf");

using (StreamWriter sw = new StreamWriter(path))

{

sw.WriteLine("0\nSECTION\n2\nENTITIES");

float w =

(float)CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

.PUBLIC_STATIC_DOUBLE_MAX_WIDTH_MIKROSEC_FOUND_IN_OVERALL_IN_CRESTS_AND_TROUGHS;

//ct.BoundingBox.Width;

////// float h =

////// // 10000f;

////// (float)

//////.PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUNDOVERALL_IN_CRESTS_AND_TROUGHS;

///

float h =

// 10000f;

(float)

(CrestTroughAnalyzer___SANJOY_NATHS_QHENOMENOLOGY_REASONING_SYSTEMS_DISMANTLES_ANY_WAVES_TO_CREST_AABB_TRANSPARENT_RECTANGLES_TROUGH_AABB_TRANSPARENT_RECTANGLES_AND_STACK_THESE_TRANSPARENT_AABB_RECTANGLES_ONE_ABOVE_ANOTHER_GETS_VERTICAL_STRIPS_OF_CG_TRACINGS_ON_TRACING_PAPER_STACKS_BITMAPS_DXF_CSV_REPORTS

.PUBLIC_STATIC_DOUBLE_MAX_ABS_AMPLITUDES_FOUND_10000_TIMES_FOUNDOVERALL_IN_CRESTS_AND_TROUGHS)

* 10000f

;

// ct.BoundingBox.Height;

float left = 0f;// cx - w / 2;

float right = w;// cx + w / 2;

float top = h;// ct.IsCrest ? 0 + h : 0;

float bottom = -h;// ct.IsCrest ? 0 : 0 - h;

int color = 6;// ct.IsCrest ? 5 : 1;

float center_x = w / 2;// 0;

//////// Bounding box edges (4 lines)

sw.WriteLine($"0\nLINE\n8\n0\n62\n{color}\n10\n{left:F3}\n20\n{top:F3}\n30\n0\n11\n{right:F3}\n21\n{top:F3}\n31\n0"); // top

sw.WriteLine($"0\nLINE\n8\n0\n62\n{color}\n10\n{left:F3}\n20\n{bottom:F3}\n30\n0\n11\n{right:F3}\n21\n{bottom:F3}\n31\n0"); // bottom

sw.WriteLine($"0\nLINE\n8\n0\n62\n{color}\n10\n{left:F3}\n20\n{top:F3}\n30\n0\n11\n{left:F3}\n21\n{bottom:F3}\n31\n0"); // left

sw.WriteLine($"0\nLINE\n8\n0\n62\n{color}\n10\n{right:F3}\n20\n{top:F3}\n30\n0\n11\n{right:F3}\n21\n{bottom:F3}\n31\n0"); // right

//////// Axes lines

color = 1;//

sw.WriteLine($"0\nLINE\n8\n0\n62\n8\n10\n{left:F3}\n20\n0.000\n30\n0\n11\n{right:F3}\n21\n0.000\n31\n0"); // X axis

// sw.WriteLine($"0\nLINE\n8\n0\n62\n8\n10\n{cx:F3}\n20\n{bottom:F3}\n30\n0\n11\n{cx:F3}\n21\n{top:F3}\n31\n0"); // Y axis

sw.WriteLine($"0\nLINE\n8\n0\n62\n8\n10\n{center_x:F3}\n20\n{bottom:F3}\n30\n0\n11\n{center_x:F3}\n21\n{top:F3}\n31\n0"); // Y axis

/// crestTroughs.ToArray<CrestTroughObject>().