Новая идея (возможно) в цифровой обработке сигнала

Const
   SCAN_COUNT     =  1024;
Type
   TScanBuf = array[0..SCAN_COUNT_ - 1]  of  word;

TSigPart = record
     StartPos, EndPos, maxPos : word; // позиции в TScanBuf начала, конца и максимального значения
     StartVal, EndVal, MaxValue : Word; // начальное, конечное и максимальное значения
     MinusValue : Word; // Далее пригодится для обработки
  end;
 
TSigParts = array of TSigPart;

var
    i, n : Integer;
    CP : Integer; // это кол. получившихся частей
    StartPos : word; // с какой позиции будет начинаться поиск и разбиение.
    niz, Ch : boolean;
    ci : TScanBuf; //входные данные
    SigParts : TSigParts // выходные данные
 begin
    StartPos := 5; // мне не нужно было начинать с 0, потому как в начале всегда лажа
 
    // ищем реальное начало, когда данные в массиве начинают изменяться
   // 55555555 или 000000 пропускаем
    i := StartPos;
    while (i < SCAN_COUNT_) and (ci[StartPos-1] = ci[i]) do
      inc(i);
 
    StartPos := i; 
    SetLength(SigParts, 1);
    CP := 0;
    n := 0;
 
    SigParts [n].StartPos := StartPos;
    SigParts [n].EndPos := 0;
    SigParts [n].StartVal := ci[StartPos-1];
    SigParts [n].EndVal := ci[StartPos-1];
    SigParts [n].MaxValue := ci[StartPos-1];
    niz := false;  // эта переменная говорит о том что данные начали уменьшаться, т.е пик найден      
                           //ищем его завершение.
    Ch := False;
    i := StartPos;
    while I < SCAN_COUNT do begin
      if ci[i-1] <= ci[i] then begin // текущий больше предыдущего или равен, идем вверх
        if niz then begin // если до этого было движение вниз, значит начался новый пик
          //если  после того как спуск закончен идут ровная линия, мы пропускаем до начала следующего пика
          while (ci[i-1] = ci[i]) and (i < (SCAN_COUNT-1)) do // пропускаем
            inc(i);
          // доб. новый эл. массива
          inc(n);
          SetLength(DT, n+1);
          SigParts [n].StartVal := ci[i-1];
          SigParts [n].StartPos := i-1;
          niz := false;
        end;
 
        if ci[i-1] > ci[i] then begin // если после окончания пика идет ровная линия и спуск
          SigParts [n].MaxValue := ci[i-1];
          SigParts [n].maxPos := i-1;
          SigParts [n].EndVal := ci[i];
          SigParts [n].EndPos := i;
          niz := True;
        end else begin
          SigParts [n].MaxValue := ci[i];
          SigParts [n].maxPos := i;
        end;
      end else begin
        SigParts [n].EndVal := ci[i];
        SigParts [n].EndPos := i;
        niz := True;
      end;
      inc(i);
    end;
 
    if SigParts [n].MaxValue = 0 then begin // последний кусок может быть не закончен, удаляем его
      Dec(n);
      SetLength(SigParts, n+1);
    end;
    CP := n;
 end;

var
  i, j, n, t : integer;
  Si    : TScanBuf; // входной массив
  Si2  : TScanBuf; // выходной массив
  SigParts : TSigParts;
begin
  n := GetPicArray(SigParts, Si); // Это функция которая разбивает входной сигнал на куски «пики».
  // в n присвоено кол эл. массива SigParts
  FillChar(SI2,  sizeof(TScanBuf), 0); // зануляем выходной массив
  for I := 0 to n - 1 do begin
    if SigParts[i].StartVal > SigParts[i].EndVal then // выбираем что больше, значения начала пика или конца и  
                                                                                       //присваиваем в SigParts[i].MinusValue
      SigParts[i].MinusValue := SigParts[i].StartVal 
    else
      SigParts[i].MinusValue := SigParts[i].EndVal;
    for j := SigParts[i].StartPos to SigParts[i].EndPos do begin // идем по исходному массиву
      t := si[j] - SigParts[i].MinusValue; // вычитаем из исходного массива SigParts[i].MinusValue
      if t < 0 then // Если после вычитания значение получилось меньше 0 присваиваем 0
        si2[j] := 0
      else
        si2[j] := t;
    end;
  end;

var
  i, j, n : integer;
  TM  :  integer;  // максимальное значение порога
  dm, dk : integer;
  Si    : TScanBuf; // входной массив
  SiThreshold  : TScanBuf; // выходной массив
  SigParts : TSigParts;
 
Begin
  FillChar(SiThreshold, sizeof(TScanBuf), 0); // зануляем все значения массива
  n := GetPicArray(SigParts,  Si);  //рабиваем
  dm := 0;
  dk := 0;
  TM := 0;
 
  for i  := n div 2 to n-2 do begin // берем сразу со среднего эл. Чтоб долго не перебирать ненужное
    if SigParts[i].maxPos >= 850 then begin // почему 850, по тому что мне так захотелось 
      dm := dm + Abs(SigParts [i].MaxValue - SigParts [i+1].MaxValue); // сумма разности начала и конца пиков
      Inc(dk); // кол. сложенных пиков
    end;
    TM := TM + SigParts [i].MaxValue; // сумма максимумов
  end;
 
  if (TM<> 0) and (n > 3) then // если у нас больше 3 кусков получилось,  тогда считаем
    TM := Round(TM/(n div 2 -1)*1.5)// сумму делим на количество и добавляем коэффициент 
  else
    TM := 40; // выбрано опытным путем
 
  if dk < 5 then
    dm := 10
  else
    dm := Round((dm/dk)*1.9);
 
  d1 := dm;  // для начала чему-нибудь присваиваем например «коэффициенту добавления к порогу»
// Далее в d1 будет лежать предыдущее «среднее максимумов 3-х соседствующих пиков»
  TM;
  for I := 1 to n-2 do begin
    d2 := SigParts[i-1].MaxValue;
    d2 := d2 + SigParts[i].MaxValue;
    d2 := (d2 + SigParts[i+1].MaxValue) / 3; // среднее значение максимумов 3-х соседствующих пиков 
    b := SigParts[i].EndPos - SigParts[i-1].StartPos; // кол. отсчетов от начала предыдущего пика до конца этого
    for j := SigParts[i-1].StartPos to SigParts[i].EndPos do begin
      s1 := round(d1+(d2-d1)/b*(j - SigParts[i-1].StartPos))+dm;  //значение d2+dm  должно быть в последнем 
//отчете нашей выборки, в этой формуле мы просто делаем плавное изменение значения от 
// SigParts[i-1].StartPos (d1+dm) до SigParts[i].EndPos (d2+dm)
      if s1 < TM then // проверяем, чтоб расчетный порог небыл больше максимально возможного
        SiThreshold[j] := s1
      else
        SiThreshold[j] := TM;
    end;
    d1 := d2;
  end;
 
  if n > 1 then begin // заполняем хвост буфера порога значениями, чтоб там нулей небыло.
    for j := SigParts[n-2].StartPos to SCAN_COUNT - 1 do begin
      if s1 < s then
         SiThreshold[j] := s1
      else
        SiThreshold[j] := TM;
    end;
  end;
end.

    n := GetPicArray(SigParts, SiInput );
    FillChar(SiOutput, sizeof(TScanBuf), 0);
    for I := 0 to n do begin
      for j := SigParts[i].StartPos to SigParts[i].EndPos do
        if (SiThreshold[j] < SigParts[i].MaxValue) then begin
           SiOutput [j] := SiInput;
        end;
    end;

Var
  Kn : integer; // кол. эл. в массиве SigParts1
  SigParts1 : TSigParts; 
  SigParts2: TSigParts;
 
  function FindPic(InputIndex : integer) : integer;
  const
     step = 10;
  var
     k : integer; // кол. эл. SigParts1 с которыми мы уже сравнили 
     j, i : integer; // эл. SigParts1 который мы сравниваем в данный момент
     tl, tr : integer; // границы поиска
  begin
    k := 0;
    tl := InputIndex - step;
    tr := InputIndex + step-1;
    if InputIndex >= kn then // если текущий индекс "пика" больше чем кол. "пиков" в сигнале1
      j  := kn -1
    else
      j := InputIndex;
    i := InputIndex+1;
    Result := -1;
    while k < kn do begin
      while (j >= Tl) and (j >= 0) do begin // двигаемся к 0
        if (SigParts1 [j].StartPos <= SigParts2 [InputIndex].maxPos) and
           (SigParts1 [j].EndPos >= SigParts 2[InputIndex].maxPos) then begin
          Result := j;
          Exit;
        end;
        dec(j);
        inc(k);
      end;
      while (i <= Tr) and (i < kn) do begin // двигаемся к kn (кол. эл. в массиве SigParts2)
        if (SigParts1 [i].StartPos <= SigParts2 [InputIndex].maxPos) and
           (SigParts1 [i].EndPos >= SigParts 2[InputIndex].maxPos) then begin
          Result := i;
          Exit;
        end;
        inc(i);
        inc(k);
      end;
      Tl := Tl - step;
      Tr := Tr + step;    end;
  end;