kopia lustrzana https://github.com/ag1le/morse-wip
2014-May-25 Fixed bugs and syncronized with FLDIGI 3.21.77 Bayesian v3 version.
- tested with pile-up and WW WPX contest examples, works better nowmaster
AG1LE Mauri
rodzic
22879852fe
commit
58e19f6b52
|
|
@ -174,10 +174,10 @@ static double calc_magnitude (const double * freq, int freqlen, double * magnitu
|
|||
int k ;
|
||||
double max = 0.0 ;
|
||||
|
||||
for (k = 1 ; k < freqlen / 2 ; k++)
|
||||
{ magnitude [k] = sqrt (freq [k] * freq [k] + freq [freqlen - k - 1] * freq [freqlen - k - 1]) ;
|
||||
for (k = 1 ; k < freqlen / 2 ; k++) {
|
||||
magnitude[k] = sqrt (freq [k] * freq [k] + freq [freqlen - k - 1] * freq [freqlen - k - 1]) ;
|
||||
max = MAX (max, magnitude [k]) ;
|
||||
} ;
|
||||
} ;
|
||||
magnitude [0] = 0.0 ;
|
||||
|
||||
return max ;
|
||||
|
|
@ -483,19 +483,20 @@ decode_sndfile (SNDFILE *infile, SF_INFO info)
|
|||
single_max = calc_magnitude (freq_domain, 2 * speclen, single_mag_spec) ;
|
||||
|
||||
// print one FFT row - just to check
|
||||
/*
|
||||
if (once) {
|
||||
|
||||
if (1) { //was once
|
||||
printf("\nmax:%f", single_max);
|
||||
for (int i=0; i< speclen; i++)
|
||||
printf("\n%f",single_mag_spec[i]);
|
||||
once=0;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
// detect peaks in the FFT spectrum
|
||||
peak_detect(single_mag_spec, speclen, &p);
|
||||
|
||||
// print found freq peaks - only once
|
||||
if (once ) {
|
||||
if (1 ) {
|
||||
for (i=0; i <p.mxcount; i++) {
|
||||
int Hz = (p.mxpos[i]*(sr/2))/(speclen);
|
||||
printf("peak[%d]:%f\tHz:%d\tmaxcount:%d\n",p.mxpos[i],p.mx[i],Hz,p.mxcount);
|
||||
|
|
@ -507,7 +508,7 @@ decode_sndfile (SNDFILE *infile, SF_INFO info)
|
|||
|
||||
max_mag = MAX (max_mag, single_max) ;
|
||||
single_max = filter(single_max,bfv);
|
||||
process_data(single_max/max_mag); // decode Morse code here
|
||||
// process_data(single_max/max_mag); // decode Morse code here
|
||||
|
||||
// interp_spec (mag_spec [w], height, single_mag_spec, speclen) ;
|
||||
} ;
|
||||
|
|
|
|||
|
|
@ -24,12 +24,12 @@
|
|||
#include <stdio.h>
|
||||
|
||||
int morse::likhd_(real *z, real *rn, integer *ip, integer *lambda,
|
||||
real *dur, integer *ilrate, real *p, real *lkhd)
|
||||
real *dur, integer *ilrate)
|
||||
{
|
||||
|
||||
/* Local variables */
|
||||
static integer i, j, k, n;
|
||||
static real pin;
|
||||
static real pinr;
|
||||
static integer ilx, ixs;
|
||||
static real lkhdj;
|
||||
static integer kelem;
|
||||
|
|
@ -58,8 +58,8 @@ int morse::likhd_(real *z, real *rn, integer *ip, integer *lambda,
|
|||
|
||||
/* OBTAIN SAVED KEYSTATE: */
|
||||
/* Parameter adjustments */
|
||||
--lkhd;
|
||||
p -= 26;
|
||||
// --lkhd;
|
||||
// p -= 26; //pin
|
||||
|
||||
/* Function Body */
|
||||
if (*lambda == 0) {
|
||||
|
|
@ -75,12 +75,13 @@ int morse::likhd_(real *z, real *rn, integer *ip, integer *lambda,
|
|||
israte = i;
|
||||
n = (i - 1) * 6 + k;
|
||||
j = (*ip - 1) * 30 + n;
|
||||
pin = p[*ip + n * 25];
|
||||
// pinr = p[*ip + n * PATHS];
|
||||
pinr = pin[n-1][*ip -1];
|
||||
/* COMPUTE AND STORE LIKELIHOOD: */
|
||||
kalfil_(z, ip, rn, &ilx, &ixs, &kelem, &j, &israte, dur, ilrate,&pin, &lkhdj);
|
||||
lkhd[j] = lkhdj;
|
||||
kalfil_(z, ip, rn, &ilx, &ixs, &kelem, &j, &israte, dur, ilrate,&pinr, &lkhdj);
|
||||
lkhd[n-1][*ip-1] = lkhdj;
|
||||
// goto L100;
|
||||
if (pin > 1e-6f) {
|
||||
if (pinr > 1e-6f) {
|
||||
|
||||
//printf("\nz:%f ip:%3d rn:%f ilx:%d ixs:%d kelem:%d j:%4d israte:%d dur:%4.1f ilrate:%d pin:%f lkhd:%f",(double)*z,(int)*ip,(double)*rn,(int)ilx,(int)ixs,(int)kelem,(int)j,(int)israte,(double)*dur,(int)*ilrate,(double)pin,(double)lkhdj);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,14 +23,14 @@
|
|||
#include "bmorse.h"
|
||||
#include <stdio.h>
|
||||
|
||||
int morse::probp_(real *p, real *pin, integer *isave, real *lkhd)
|
||||
int morse::probp_(real *p, integer *isave)
|
||||
{
|
||||
/* System generated locals */
|
||||
integer i1;
|
||||
|
||||
/* Local variables */
|
||||
integer i, j, n, ni;
|
||||
real pmax, psav[750], psum;
|
||||
real pmax, psav[30*PATHS], psum;
|
||||
|
||||
|
||||
/* PROBP COMPUTES THE POSTERIOR PROBABILITY OF EACH NEW PATH */
|
||||
|
|
@ -43,8 +43,8 @@ int morse::probp_(real *p, real *pin, integer *isave, real *lkhd)
|
|||
/* PSUM- NORMALIZING CONSTANT (SUM OF P(J)) */
|
||||
|
||||
/* Parameter adjustments */
|
||||
--lkhd;
|
||||
pin -= 26;
|
||||
// --lkhd;
|
||||
// pin -= 26;
|
||||
--p;
|
||||
|
||||
/* Function Body */
|
||||
|
|
@ -57,7 +57,8 @@ int morse::probp_(real *p, real *pin, integer *isave, real *lkhd)
|
|||
/* COMPUTE IDENTITY OF NEW PATH: */
|
||||
j = (i - 1) * 30 + n;
|
||||
/* PRODUCT OF PROBS, ADD TO PSUM */
|
||||
psav[j - 1] = p[i] * pin[i + n * 25] * lkhd[j];
|
||||
// psav[j - 1] = p[i] * pin[i + n * PATHS] * lkhd[j];
|
||||
psav[j - 1] = p[i] * pin[n-1][i-1] * lkhd[n-1][i-1];
|
||||
psum += psav[j - 1];
|
||||
if (psav[j - 1] <= pmax) {
|
||||
goto L100;
|
||||
|
|
|
|||
|
|
@ -21,30 +21,27 @@
|
|||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "bmorse.h"
|
||||
#include <stdio.h>
|
||||
|
||||
int morse::proces_(real *z, real *rn, integer *xhat, real *px, integer *elmhat, real *spdhat, integer *imax, real * pmax, int spd)
|
||||
{
|
||||
/* Initialized data */
|
||||
|
||||
static integer isave = 25;
|
||||
static integer lambda[25];
|
||||
static integer ilrate[25];
|
||||
static real dur[25];
|
||||
static integer pathsv[25];
|
||||
static integer sort[25];
|
||||
static integer isave = PATHS;
|
||||
static integer lambda[PATHS];
|
||||
static integer ilrate[PATHS];
|
||||
static real dur[PATHS];
|
||||
static integer pathsv[PATHS];
|
||||
static integer sort[PATHS];
|
||||
|
||||
static real p[750];
|
||||
static integer lamsav[750];
|
||||
static real dursav[750];
|
||||
static integer ilrsav[750];
|
||||
static real pin[750] /* was [25][30] */, lkhd[750];
|
||||
static real p[30*PATHS];
|
||||
static integer lamsav[30*PATHS];
|
||||
static real dursav[30*PATHS];
|
||||
static integer ilrsav[30*PATHS];
|
||||
|
||||
|
||||
/* System generated locals */
|
||||
integer i1;
|
||||
|
||||
/* Local variables */
|
||||
// static real pin[30][25]; // N: 5 spd x 6 morse element states I: 25 paths - transition probability from path I to state N
|
||||
// static real lkhd[30][25]; // 5 speeds x 6 morse element states x 25 paths = 750 likelyhoods
|
||||
|
||||
static integer i, retstat;
|
||||
static real pelm;
|
||||
|
|
@ -101,13 +98,15 @@ int morse::proces_(real *z, real *rn, integer *xhat, real *px, integer *elmhat,
|
|||
|
||||
|
||||
if (init) {
|
||||
for(i=0;i<25;i++) {
|
||||
for(i=0;i<PATHS;i++) {
|
||||
lambda[i] = 5;
|
||||
ilrate[i]= ((i/5+1)*10);
|
||||
dur[i]=9e3f;
|
||||
pathsv[i]=5;
|
||||
ykkip[i] = .5f;
|
||||
pkkip[i] = .1f;
|
||||
}
|
||||
for(i=0;i<750;i++) {
|
||||
for(i=0;i<30*PATHS;i++) {
|
||||
p[i]=1.f;
|
||||
lamsav[i]=5;
|
||||
dursav[i]=0.f;
|
||||
|
|
@ -119,15 +118,15 @@ int morse::proces_(real *z, real *rn, integer *xhat, real *px, integer *elmhat,
|
|||
i1 = isave;
|
||||
for (i = 1; i <= i1; ++i) {
|
||||
ipath = i;
|
||||
trprob_(&ipath, &lambda[i - 1], &dur[i - 1], &ilrate[i - 1], pin);
|
||||
trprob_(&ipath, &lambda[i - 1], &dur[i - 1], &ilrate[i - 1]);
|
||||
path_(&ipath, &lambda[i - 1], &dur[i - 1], &ilrate[i - 1],lamsav, dursav, ilrsav);
|
||||
likhd_(z, rn, &ipath, &lambda[i - 1], &dur[i - 1], &ilrate[i- 1], pin, lkhd);
|
||||
likhd_(z, rn, &ipath, &lambda[i - 1], &dur[i - 1], &ilrate[i- 1]);
|
||||
}
|
||||
/* HAVING OBTAINED ALL NEW PATHS, COMPUTE: */
|
||||
/* POSTERIOR PROBABILITY OF EACH NEW PATH(PROBP); */
|
||||
/* POSTERIOR PROBABILITY OF KEYSTATE, ELEM STATE, */
|
||||
/* CONDITIONAL MEAN ESTIMATE OF SPEED(SPROB); */
|
||||
probp_(p, pin, &isave, lkhd);
|
||||
probp_(p, &isave);
|
||||
sprob_(p, &isave, ilrsav, &pelm, elmhat, spdhat, px);
|
||||
|
||||
*xhat = 0;
|
||||
|
|
@ -143,6 +142,10 @@ int morse::proces_(real *z, real *rn, integer *xhat, real *px, integer *elmhat,
|
|||
/* OBTAIN LETTER STATE ESTIMATE: */
|
||||
|
||||
retstat=trelis_(&isave, pathsv, lambda, imax, &ipmax);
|
||||
if (pathsv[0] > 1358 ) {
|
||||
printf("\n pathsv[0]:%d", pathsv[0]);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return retstat;
|
||||
} /* proces_ */
|
||||
|
|
|
|||
|
|
@ -30,22 +30,20 @@ int morse::savep_(real *p, integer *pathsv, integer *isave, integer
|
|||
{
|
||||
/* Initialized data */
|
||||
|
||||
real popt = .9f;
|
||||
real popt = .999f; // was 0.9f
|
||||
|
||||
/* System generated locals */
|
||||
integer i1, i2;
|
||||
|
||||
/* Local variables */
|
||||
integer i, j, k, n, ip, jsav, nsav;
|
||||
real psav[25], psum;
|
||||
integer iconv[25], ipsav, isavm1, nplus1;
|
||||
real psav[PATHS], psum;
|
||||
integer iconv[PATHS], ipsav, isavm1, nplus1;
|
||||
|
||||
|
||||
/* THIS SUBROUTINE PERFORMS THE ALGORITM TO SAVE */
|
||||
/* THE PATHS WITH HIGHEST POSTERIOR PROBABILITY. */
|
||||
/* IT WILL SAVE A MINIMUM OF 7 PATHS (ONE FOR EACH */
|
||||
/* ELEMENT STATE AND ONE ADDITIONAL NODE), AND */
|
||||
/* A MAXIMUM OF 25 PATHS. WITHIN THESE LIMITS, IT */
|
||||
/* A MAXIMUM OF "PATHS" PATHS. WITHIN THESE LIMITS, IT */
|
||||
/* SAVED ONLY ENOUGH TO MAKE THE TOTAL SAVED PROBABILITY */
|
||||
/* EQUAL TO POPT. */
|
||||
|
||||
|
|
@ -89,8 +87,7 @@ int morse::savep_(real *p, integer *pathsv, integer *isave, integer
|
|||
/* SELECT SIX HIGHEST PROB ELEMENT STATE NODES: */
|
||||
for (k = 1; k <= 6; ++k) {
|
||||
*pmax = 0.f;
|
||||
i1 = *isave;
|
||||
for (ip = 1; ip <= i1; ++ip) {
|
||||
for (ip = 1; ip <= *isave; ++ip) {
|
||||
for (i = 1; i <= 5; ++i) {
|
||||
j = (ip - 1) * 30 + (i - 1) * 6 + k;
|
||||
if (p[j] >= *pmax) {
|
||||
|
|
@ -113,12 +110,11 @@ int morse::savep_(real *p, integer *pathsv, integer *isave, integer
|
|||
/* PROBABILITY SAVED EQUAL TO POPT, OR A MAX OF 25: */
|
||||
do {
|
||||
*pmax = 0.f;
|
||||
i1 = *isave;
|
||||
for (ip = 1; ip <= i1; ++ip) {
|
||||
|
||||
for (ip = 1; ip <= *isave; ++ip) {
|
||||
for (n = 1; n <= 30; ++n) {
|
||||
j = (ip - 1) * 30 + n;
|
||||
i2 = nsav;
|
||||
for (i = 1; i <= i2; ++i) {
|
||||
for (i = 1; i <= nsav; ++i) {
|
||||
if (j == sort[i]) {
|
||||
goto L500;
|
||||
}
|
||||
|
|
@ -140,19 +136,19 @@ int morse::savep_(real *p, integer *pathsv, integer *isave, integer
|
|||
if (psum >= popt) {
|
||||
break;
|
||||
}
|
||||
} while (nsav < 25);
|
||||
} while (nsav < PATHS);
|
||||
/* NEW ISAVE EQUALS NO. OF NODES SAVED: */
|
||||
*isave = nsav;
|
||||
|
||||
/* SORT THE SAVED ARRAYS TO OBTAIN THE ARRAYS */
|
||||
/* TO BE USED FOR THE NEXT ITERATION: */
|
||||
if (psum ==0.0) {
|
||||
printf("\nsavep: psum = 0");
|
||||
// printf("\nsavep: psum = 0");
|
||||
return 0;
|
||||
}
|
||||
|
||||
i1 = *isave;
|
||||
for (i = 1; i <= i1; ++i) {
|
||||
|
||||
for (i = 1; i <= *isave; ++i) {
|
||||
p[i] = psav[i - 1] / psum;
|
||||
lambda[i] = lamsav[sort[i]];
|
||||
dur[i] = dursav[sort[i]];
|
||||
|
|
@ -160,17 +156,17 @@ int morse::savep_(real *p, integer *pathsv, integer *isave, integer
|
|||
ykkip[i - 1] = ykksv[sort[i] - 1];
|
||||
pkkip[i - 1] = pkksv[sort[i] - 1];
|
||||
}
|
||||
i1 = *isave;
|
||||
for (i = 1; i <= i1; ++i) {
|
||||
|
||||
for (i = 1; i <= *isave; ++i) {
|
||||
iconv[i - 1] = 1;
|
||||
}
|
||||
isavm1 = *isave - 1;
|
||||
i1 = isavm1;
|
||||
for (n = 1; n <= i1; ++n) {
|
||||
|
||||
|
||||
for (n = 1; n <= *isave - 1; ++n) {
|
||||
if (iconv[n - 1] != 0) {
|
||||
nplus1 = n + 1;
|
||||
i2 = *isave;
|
||||
for (k = nplus1; k <= i2; ++k) {
|
||||
|
||||
for (k = nplus1; k <= *isave; ++k) {
|
||||
if (iconv[k - 1] == 0) {
|
||||
goto L810;
|
||||
}
|
||||
|
|
@ -189,10 +185,11 @@ int morse::savep_(real *p, integer *pathsv, integer *isave, integer
|
|||
}
|
||||
}
|
||||
}
|
||||
psum = 0.f;
|
||||
|
||||
// psum = p[0];
|
||||
psum = p[1];
|
||||
n = 1;
|
||||
i1 = *isave;
|
||||
for (i = 2; i <= i1; ++i) {
|
||||
for (i = 2; i <= *isave; ++i) {
|
||||
if (iconv[i - 1] != 0) {
|
||||
++n;
|
||||
lambda[n] = lambda[i];
|
||||
|
|
@ -208,14 +205,13 @@ int morse::savep_(real *p, integer *pathsv, integer *isave, integer
|
|||
}
|
||||
/* ALSO OBTAIN HIGHEST PROBABILITY NODE: */
|
||||
if (psum ==0.0) {
|
||||
printf("\nsavep_2: psum = 0");
|
||||
// fprintf(2,"\nsavep_2: psum = 0");
|
||||
return 0;
|
||||
}
|
||||
|
||||
*isave = n;
|
||||
*pmax = 0.f;
|
||||
i1 = *isave;
|
||||
for (i = 1; i <= i1; ++i) {
|
||||
for (i = 1; i <= *isave; ++i) {
|
||||
p[i] /= psum;
|
||||
if (p[i] > *pmax) {
|
||||
*pmax = p[i];
|
||||
|
|
|
|||
|
|
@ -30,17 +30,17 @@ int morse::trelis_(integer *isave, integer *pathsv, integer *lambda, integer *im
|
|||
{
|
||||
/* Initialized data */
|
||||
|
||||
static integer lmdsav[25][NDELAY]; /* was [200][25] */
|
||||
static integer lmdsav[PATHS][NDELAY]; /* was [200][PATHS] */
|
||||
static integer n = 0;
|
||||
static integer ndelay = NDELAY;
|
||||
static integer ipnod[25];
|
||||
static integer ipnod[PATHS];
|
||||
static integer ncall = 0;
|
||||
static integer nmax = 0;
|
||||
static integer mmax = 0;
|
||||
static integer ltrsv[NDELAY];
|
||||
static integer kd = 0;
|
||||
static integer ndelst = 0;
|
||||
static integer pthtrl[25][NDELAY]; /* was [200][25] */
|
||||
static integer pthtrl[PATHS][NDELAY]; /* was [200][PATHS] */
|
||||
static integer iend = 0;
|
||||
|
||||
|
||||
|
|
@ -74,7 +74,7 @@ int morse::trelis_(integer *isave, integer *pathsv, integer *lambda, integer *im
|
|||
init = 1;
|
||||
for (i=0; i< NDELAY; i++)
|
||||
ltrsv[i] = 0;
|
||||
for (int row =0; row < 25; row++) {
|
||||
for (int row =0; row < PATHS; row++) {
|
||||
ipnod[row] = 1;
|
||||
for (int col =0; col < NDELAY; col++){
|
||||
lmdsav[row][col] = 0;
|
||||
|
|
@ -102,7 +102,7 @@ int morse::trelis_(integer *isave, integer *pathsv, integer *lambda, integer *im
|
|||
xnmax = (real) nmax;
|
||||
xnmax /= ncall;
|
||||
}
|
||||
if (*isave == 25) {
|
||||
if (*isave == PATHS) {
|
||||
++mmax;
|
||||
xmmax = (real) mmax;
|
||||
xmmax /= ncall;
|
||||
|
|
@ -196,10 +196,10 @@ L350:
|
|||
i = ndelay + i;
|
||||
}
|
||||
// ltrsv[kd - 1] = lmdsav[i + ip * NDELAY-NDELAY-1];
|
||||
if (ip > 26) {
|
||||
printf("\nTRELIS.CXX: Error line 196 ip:%d",ip);
|
||||
return(-1);
|
||||
}
|
||||
// if (ip > 26) {
|
||||
// printf("\nTRELIS.CXX: Error line 196 ip:%d",ip);
|
||||
// return(-1);
|
||||
// }
|
||||
ltrsv[kd - 1] = lmdsav[ip-1][i-1];
|
||||
// ip = pthtrl[i + ip * NDELAY-NDELAY-1];
|
||||
ip = pthtrl[ip-1][i-1];
|
||||
|
|
|
|||
|
|
@ -23,10 +23,10 @@
|
|||
#include "bmorse.h"
|
||||
#include <stdio.h>
|
||||
|
||||
int morse::trprob_(integer *ip, integer *lambda, real *dur, integer *ilrate, real *p)
|
||||
int morse::trprob_(integer *ip, integer *lambda, real *dur, integer *ilrate)
|
||||
{
|
||||
static integer i, k, n;
|
||||
static real pin[30];
|
||||
static real pint[30];
|
||||
static integer kelm;
|
||||
static real psum, ptrx;
|
||||
static integer ielem, irate;
|
||||
|
|
@ -50,12 +50,13 @@ int morse::trprob_(integer *ip, integer *lambda, real *dur, integer *ilrate, rea
|
|||
/* PTRANS RETURNS THE PATH-CONDITIONAL STATE TRANSITION PROB */
|
||||
/* LOOK UP ELEMENT TYPE FOR LTR STATE LAMBDA: */
|
||||
/* Parameter adjustments */
|
||||
p -= 26;
|
||||
// p -= 26;
|
||||
|
||||
/* Function Body */
|
||||
if (*lambda == 0) {
|
||||
for (n = 1; n <= 30; ++n) {
|
||||
p[*ip + n * 25] = 0.f;
|
||||
// p[*ip + n * PATHS] = 0.f;
|
||||
pin[n-1][*ip-1] = 0.f;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -71,7 +72,7 @@ int morse::trprob_(integer *ip, integer *lambda, real *dur, integer *ilrate, rea
|
|||
n = (i - 1) * 6 + k;
|
||||
kelm = k;
|
||||
irate = i;
|
||||
ptrans_(&kelm, &irate, lambda, ilrate, &ptrx, &psum, pin, &n);
|
||||
ptrans_(&kelm, &irate, lambda, ilrate, &ptrx, &psum, pint, &n);
|
||||
}
|
||||
}
|
||||
if (psum ==0.0) {
|
||||
|
|
@ -80,10 +81,10 @@ int morse::trprob_(integer *ip, integer *lambda, real *dur, integer *ilrate, rea
|
|||
}
|
||||
|
||||
for (n = 1; n <= 30; ++n) {
|
||||
p[*ip + n * 25] = pin[n - 1] / psum;
|
||||
// p[*ip + n * PATHS] = pint[n - 1] / psum;
|
||||
pin[n-1][*ip-1] = pint[n - 1] / psum;
|
||||
}
|
||||
|
||||
L200:
|
||||
return 0;
|
||||
} /* trprob_ */
|
||||
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ doublereal morse::xtrans_(integer *ielem, real *d0, integer *irate)
|
|||
|
||||
/* SCALE DURATION AND OBTAIN DENSITY PARAMETER: */
|
||||
|
||||
mscale = kimap[(0 + (0 + ((*ielem - 1) << 2))) / 4];
|
||||
mscale = kimap[*ielem - 1];
|
||||
rscale = 1200.f / *irate;
|
||||
b0 = *d0 / (mscale * rscale);
|
||||
b1 = (*d0 + 5.f) / (mscale * rscale);
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue