void hilbert(float dist, int n, int parity)
// moves forward drawing a curve to left if parity = 1, right if -1.
{
left(90*parity);
if(n > 0) hilbert(dist,n-1, -parity);
forward(dist);
right(90*parity);
if(n > 0) hilbert(dist,n-1,parity);
forward(dist);
if(n > 0) hilbert(dist,n-1,parity);
right(90*parity);
forward(dist);
if(n > 0) hilbert(dist,n-1, -parity);
left(90*parity);
}
/*************************************************
********************FOR GUI***********************
*************************************************/
QVector<QVector<double>> sleep_apnea::sleep_apnea_plots(QVector<unsigned int> tab_R_peaks)
{
//getting data
QVector<QVector<double>>tab_RR,tab_RR_new,tab_res;
QVector<QVector<double>>h_amp(2);
QVector<QVector<double>>h_freq(2);
QVector<QVector<double>> apnea_plots(3);
tab_RR=RR_intervals(tab_R_peaks);
tab_RR_new=averange_filter(tab_RR);
tab_res=resample(tab_RR_new);
HP_LP_filter(tab_res);
hilbert(tab_res,h_amp,h_freq);
freq_amp_filter(h_freq,h_amp);
median_filter(h_freq,h_amp);
//resizing output
apnea_plots[0].resize(h_amp[0].size());
apnea_plots[1].resize(h_amp[1].size());
apnea_plots[2].resize(h_freq[1].size());
//writing output
int i;
for(i=0;i<apnea_plots[0].size();i++)apnea_plots[0][i]=h_amp[0][i];
for(i=0;i<apnea_plots[1].size();i++)apnea_plots[1][i]=h_amp[1][i];
for(i=0;i<apnea_plots[2].size();i++)apnea_plots[2][i]=h_freq[1][i];
return apnea_plots;
}
void
hilbertTransform1D(const cv::Mat & input,
cv::Mat & output,
bool label)
{
cv::Mat temp;
input.copyTo(temp);
if(temp.cols != 1 && temp.rows != 1){
cout<<"Input must be a 1D matrix"<<endl;
}
int length = (temp.rows > temp.cols)? temp.rows : temp.cols;
if(input.cols == 1)
cv::transpose(temp, temp);
cv::Mat hilbert(1, length, CV_32FC1);
int half_len = (length-1)/2;
for(int i = 0; i < hilbert.cols; i++){
int m = i-half_len;
if( m % 2 == 0)
hilbert.at<float>(0, i) = 0.0;
else
hilbert.at<float>(0, i) = 1.0/(M_PI*double(m));
}
convolveDFT(temp, hilbert, temp, label);
if(input.cols == 1)
cv::transpose(temp, temp);
temp.copyTo(output);
//clean up;
temp.release();
hilbert.release();
}
hilbertcurve::point_container_t hilbertcurve::hilbert(int order) {
point_container_t result;
if (order == 1) {
result.resize(4);
result[0] = std::make_pair(2, 1);
result[1] = std::make_pair(1, 1);
result[2] = std::make_pair(1, 2);
result[3] = std::make_pair(2, 2);
} else {
point_container_t rec = hilbert(order - 1), tmp;
int n = 1 << (order - 1);
int meta_n = (int) rec.size();
result.resize(meta_n * 4);
tmp = aftrans(order - 1, 0, rec, n, 0);
std::copy(tmp.begin(), tmp.end(), result.begin());
tmp = aftrans(order - 1, 1, rec, 0, 0);
std::copy(tmp.begin(), tmp.end(), result.begin() + meta_n);
tmp = aftrans(order - 1, 2, rec, 0, n);
std::copy(tmp.begin(), tmp.end(), result.begin() + meta_n * 2);
tmp = aftrans(order - 1, 3, rec, n, n);
std::copy(tmp.begin(), tmp.end(), result.begin() + meta_n * 3);
}
return result;
}
int envelope(int numsamp,const double *f,double *fenv)
{
int hilbert();
int i;
double *fhilb;
if(numsamp<=0) {
fprintf(stderr,"%s\n","No data points read ....");
return (1);
}
fhilb = (double *) malloc(numsamp * sizeof(double));
if (fhilb == NULL) {
fprintf(stderr,"Incorrect allocation\n");
return (2);
}
hilbert(numsamp,f,fhilb);
for( i=0; i<numsamp; i++)
fenv[i] = sqrt(f[i]* f[i] + fhilb[i]*fhilb[i]);
free(fhilb);
return (0);
}
int hilbert_(const int *numsamp,double *f,double *fhilb)
{
return hilbert(*numsamp,f,fhilb);
}
QVector<double> sleep_apnea::gui_output(QVector<unsigned int> tab_R_peaks)
{
//getting data
QVector<QVector<double>>tab_RR,tab_RR_new,tab_res;
QVector<QVector<double>>h_amp(2);
QVector<QVector<double>>h_freq(2);
QVector<BeginEndPair> apnea_output;
tab_RR=RR_intervals(tab_R_peaks);
tab_RR_new=averange_filter(tab_RR);
tab_res=resample(tab_RR_new);
HP_LP_filter(tab_res);
hilbert(tab_res,h_amp,h_freq);
freq_amp_filter(h_freq,h_amp);
median_filter(h_freq,h_amp);
apnea_output=apnea_detection(h_amp,h_freq);
//treshold_amp value for amplitude
int i; double a,b,mini_amp,mini_freq,maxi_amp,maxi_freq,mid,treshold_amp,treshold_freq;
mini_amp=99999;mini_freq=99999;
maxi_amp=0;maxi_freq=0;
for(i=0;i<h_amp[0].size();i++)
{
if(h_amp[1][i]>maxi_amp)maxi_amp=h_amp[1][i];
if(h_amp[1][i]<mini_amp)mini_amp=h_amp[1][i];
if(h_freq[1][i]>maxi_freq)maxi_freq=h_freq[1][i];
if(h_freq[1][i]<mini_freq)mini_freq=h_freq[1][i];
}
a=-0.18;b=1;mid=(maxi_amp+mini_amp)*0.5;
treshold_amp=a+b*(mid+1)*0.5;
//treshold_freq value for frequency
treshold_freq=(maxi_freq+mini_freq)*0.4;
//assessment_amp
int n_samples=0,n_apnea=0;double assessment_amp;
n_samples=double(h_amp[0][h_amp[0].size()-1]-h_amp[0][0])/data_freq;
for(int i=0;i<apnea_output.size();i++)
{n_apnea+=apnea_output[i].second-apnea_output[i].first;}
n_apnea=double(n_apnea)/data_freq;
assessment_amp=(double(n_apnea)/n_samples)*100; //*100 -> value in percent
//assessment_freq
double assessment_freq=assessment_amp;
//writing data to output
QVector<double> gui_out;
gui_out.append(treshold_amp);
gui_out.append(treshold_freq);
gui_out.append(assessment_amp);
gui_out.append(assessment_freq);
return gui_out;
}
main()
{
int i;
float zero=0.0,one=1.0,mone=-1.0;
scopy(N,&zero,0,x,1);
for (i=0; i<N; i++)
x[i] = sin(0.9*PI*i);
hilbert(N,x,y);
for (i=0; i<N; i++)
z[i] = sqrt(x[i]*x[i]+y[i]*y[i]);
pp1d(stdout,"should be 1.0",N,0,z);
}
QVector<BeginEndPair> sleep_apnea::sleep_apnea_output(QVector<unsigned int> tab_R_peaks)
{
//getting data
QVector<QVector<double>>tab_RR,tab_RR_new,tab_res;
QVector<QVector<double>>h_amp(2);
QVector<QVector<double>>h_freq(2);
QVector<BeginEndPair> apnea_output;
tab_RR=RR_intervals(tab_R_peaks);
tab_RR_new=averange_filter(tab_RR);
tab_res=resample(tab_RR_new);
HP_LP_filter(tab_res);
hilbert(tab_res,h_amp,h_freq);
freq_amp_filter(h_freq,h_amp);
median_filter(h_freq,h_amp);
apnea_output=apnea_detection(h_amp,h_freq);
//writing output
return apnea_output;
}
/** Test matrix classes */
int main()
{
hilbert();
submatrix();
sumOfSquares();
indexDenseSubmatrix();
spGetCol();
spGetRow();
spTimes();
spIndTimes();
sprGetCol();
sprGetRow();
sprTimes();
sprIndTimes();
Symmetry();
return 0;
}
int
main(int argc, char **argv)
{
FILE *headerfp=NULL; /* temporary file for trace header */
/* ... (1st trace of ensemble); */
char *key=NULL; /* header key word from segy.h */
char *type=NULL; /* ... its type */
int index; /* ... its index */
Value val; /* ... its value */
float fval = 0; /* ... its value cast to float */
float prevfval; /* ... its value of the previous trace */
complex *ct=NULL; /* complex trace */
complex *psct=NULL; /* phase-stack data array */
float *data=NULL; /* input data array */
float *hdata=NULL; /* array of Hilbert transformed input data */
float *stdata=NULL; /* stacked data ("ordinary" stack) */
float *psdata; /* phase-stack data array (real weights for PWS)*/
float a; /* inst. amplitude */
float dt; /* time sample spacing in seconds */
float pwr; /* raise phase stack to power pwr */
float sl; /* smoothing window length in seconds */
int gottrace; /* flag: set to 1, if trace is read from stdin */
int i; /* loop index */
int isl; /* smoothing window length in samples */
int nt; /* number of points on input trace */
int ntr; /* trace counter */
int ps; /* flag: output is PWS (0) or phase stack (1) */
int verbose; /* verbose flag */
cwp_Bool pws_and_cdp=cwp_false; /* are PWS and CDP set? */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if(!gettr(&intr)) err("can't get first trace");
nt = intr.ns;
/* Get parameters */
if (!getparstring("key", &key)) key="cdp";
if (!getparfloat("pwr", &pwr)) pwr = 1.0;
if (!getparfloat("dt", &dt)) dt = ((double) intr.dt)/1000000.0;
if (!getparfloat("sl", &sl)) sl = 0.0;
if (!getparint("ps", &ps)) ps = 0;
if (!getparint("verbose", &verbose)) verbose = 0;
if (STREQ(key, "cdp") && !(ps))
pws_and_cdp = cwp_true;
/* convert seconds to samples (necessary only for smoothing) */
if (!dt) {
dt = 0.004;
warn("dt not set, assuming dt=0.004");
}
/* integerized smoothing window length */
isl = NINT(fabs(sl)/dt);
if (isl>nt)
err("sl=%g too long for trace", fabs(sl));
/* diagnostic print */
if (verbose && isl)
warn("smoothing window = %d samples", isl);
/* initialize flag */
gottrace = 1;
/* get key type and index */
type = hdtype(key);
index = getindex(key);
/* Get value of key and convert to float */
prevfval = fval;
gethval(&intr, index, &val);
fval = vtof(type,val);
/* remember previous value of key */
prevfval = fval;
/* allocate space for data, hilbert transformed data, */
/* phase-stacked data and complex trace */
data = ealloc1float(nt);
hdata = ealloc1float(nt);
stdata = ealloc1float(nt);
psdata = ealloc1float(nt);
psct = ealloc1complex(nt);
ct = ealloc1complex(nt);
/* zero out accumulators */
memset( (void *) stdata, 0, nt*FSIZE);
memset( (void *) psct, 0, nt*(sizeof(complex)));
/* open temporary file for trace header */
headerfp = etmpfile();
/* store trace header in temporary file and read data */
efwrite(&intr, HDRBYTES, 1, headerfp);
/* loop over input traces */
ntr=0;
while (gottrace|(~gottrace) ) { /* middle exit loop */
/* if got a trace */
if (gottrace) {
/* get value of key */
gethval(&intr, index, &val);
fval = vtof(type,val);
/* get data */
memcpy((void *) data, (const void *) intr.data,
nt*FSIZE);
}
/* construct quadrature trace with hilbert transform */
hilbert(nt, data, hdata);
/* build the complex trace and get rid of amplitude */
for (i=0; i<nt; i++) {
ct[i] = cmplx(data[i],hdata[i]);
a = (rcabs(ct[i])) ? 1.0 / rcabs(ct[i]) : 0.0;
ct[i] = crmul(ct[i], a);
}
/* stacking */
if (fval==prevfval && gottrace) {
++ntr;
for (i=0; i<nt; ++i) {
stdata[i] += data[i];
psct[i] = cadd(psct[i],ct[i]);
}
}
/* if key-value has changed or no more input traces */
if (fval!=prevfval || !gottrace) {
/* diagnostic print */
if (verbose)
warn("%s=%g, fold=%d\n", key, prevfval, ntr);
/* convert complex phase stack to real weights */
for (i=0; i<nt; ++i) {
psdata[i] = rcabs(psct[i]) / (float) ntr;
psdata[i] = pow(psdata[i], pwr);
}
/* smooth phase-stack (weights) */
if (isl) do_smooth(psdata,nt,isl);
/* apply weights to "ordinary" stack (do PWS) */
if (!ps) {
for (i=0; i<nt; ++i) {
stdata[i] *= psdata[i] / (float) ntr;
}
}
/* set header and write PS trace or */
/* PWS trace to stdout */
erewind(headerfp);
efread(&outtr, 1, HDRBYTES, headerfp);
outtr.nhs=ntr;
if (ps) {
memcpy((void *) outtr.data,
(const void *) psdata, nt*FSIZE);
} else {
memcpy((void *) outtr.data,
(const void *) stdata, nt*FSIZE);
}
/* zero offset field if a pws and cdp stack */
if (pws_and_cdp) outtr.offset = 0;
puttr(&outtr);
/* if no more input traces, break input trace loop* */
if (!gottrace) break;
/* remember previous value of key */
prevfval = fval;
/* zero out accumulators */
ntr=0;
memset( (void *) stdata, 0, nt*FSIZE);
memset( (void *) psct, 0, nt*(sizeof(complex)));
/* stacking */
if (gottrace) {
++ntr;
for (i=0; i<nt; ++i) {
stdata[i] += data[i];
psct[i] = cadd(psct[i],ct[i]);
}
}
/* save trace header for output trace */
erewind(headerfp);
efwrite(&intr, HDRBYTES, 1, headerfp);
}
/* get next trace (if there is one) */
if (!gettr(&intr)) gottrace = 0;
} /* end loop over traces */
return(CWP_Exit());
}
// generate infill pattern as a vector of polygons
ClipperLib::Polygons Infill::makeInfillPattern(InfillType type,
const vector<Poly> tofillpolys,
double infillDistance,
double offsetDistance,
double rotation)
{
this->type = type;
//cerr << "have " << savedPatterns.size()<<" saved patterns " << endl;
// look for saved pattern for this rotation
Vector2d Min,Max;
Min = layer->getMin();
Max = layer->getMax();
ClipperLib::Polygons cpolys;
if (tofillpolys.size()==0) return cpolys;
//omp_set_lock(&save_lock);
//int tid = omp_get_thread_num( );
//cerr << "thread "<<tid << " looking for pattern " << endl;
if (type != PolyInfill) { // can't save PolyInfill
if (savedPatterns.size()>0){
//cerr << savedPatterns.size() << " patterns" << endl;
while (rotation>2*M_PI) rotation -= 2*M_PI;
while (rotation<0) rotation += 2*M_PI;
this->angle= rotation;
vector<uint> matches;
for (vector<struct pattern>::iterator sIt=savedPatterns.begin();
sIt != savedPatterns.end(); sIt++){
//cerr << sIt->Min << sIt->Max <<endl;
if (sIt->type == type &&
abs(sIt->distance-infillDistance) < 0.01 &&
abs(sIt->angle-rotation) < 0.01 )
{
//cerr << name << " found saved pattern no " << sIt-savedPatterns.begin() << " with " << sIt->cpolys.size() <<" polys"<< endl << "type "<< sIt->type << sIt->Min << sIt->Max << endl;
// is it too small for this layer?
if (sIt->Min.x > Min.x || sIt->Min.y > Min.y ||
sIt->Max.x < Max.x || sIt->Max.y < Max.y)
{
matches.push_back(sIt-savedPatterns.begin());
//break; // there is no other match
}
else {
//cerr <<"return "<< sIt->cpolys.size()<< endl;
return sIt->cpolys;
}
}
}
sort(matches.rbegin(), matches.rend());
for (uint i=0; i<matches.size(); i++) {
//cerr << i << " - " ;
savedPatterns.erase(savedPatterns.begin()+matches[i]);
}
//cerr << endl;
}
}
//omp_unset_lock(&save_lock);
// none found - make new:
bool zigzag = false;
switch (type)
{
case SmallZigzagInfill: // small zigzag lines
zigzag = true;
//case ZigzagInfill: // long zigzag lines, make lines later
case SupportInfill: // stripes, but leave them as polygons
case RaftInfill: // stripes, but leave them as polygons
case BridgeInfill: // stripes, make them to lines later
case ParallelInfill: // stripes, make them to lines later
{
Vector2d center = (Min+Max)/2.;
// make square that masks everything even when rotated
Vector2d diag = Max-Min;
double square = max(diag.x,diag.y);
Vector2d sqdiag(square*2/3,square*2/3);
Min=center-sqdiag;
Max=center+sqdiag;
//cerr << Min << "--"<<Max<< "::"<< center << endl;
Poly poly(this->layer->getZ());
for (double x = Min.x; x < Max.x; x += 2*infillDistance) {
poly.addVertex(Vector2d(x,Min.y));
if (zigzag){
for (double y = Min.y+infillDistance; y < Max.y; y += 2*infillDistance) {
poly.addVertex(Vector2d(x,y));
poly.addVertex(Vector2d(x+infillDistance,y+infillDistance));
}
for (double y = Max.y; y > Min.y; y -= 2*infillDistance) {
poly.addVertex(Vector2d(x+infillDistance,y+infillDistance));
poly.addVertex(Vector2d(x+2*infillDistance,y));
}
} else {
poly.addVertex(Vector2d(x+infillDistance,Min.y));
poly.addVertex(Vector2d(x+infillDistance,Max.y));
poly.addVertex(Vector2d(x+2*infillDistance,Max.y));
}
}
poly.addVertex(Vector2d(Max.x,Min.y-infillDistance));
poly.addVertex(Vector2d(Min.x,Min.y-infillDistance));
poly.rotate(center,rotation);
vector<Poly> polys;
polys.push_back(poly);
cpolys = Clipping::getClipperPolygons(polys);
}
break;
case HilbertInfill:
{
Poly poly(this->layer->getZ());
Vector2d center = (Min+Max)/2.;
Vector2d diag = Max-Min;
double square = MAX(Max.x,Max.y);
if (infillDistance<=0) break;
int level = (int)ceil(log2(2*square/infillDistance));
if (level<0) break;
//cerr << "level " << level;
// start at 0,0 to get the same location for all layers
poly.addVertex(Vector2d(0,0));
hilbert(level, 0, infillDistance, poly.vertices);
vector<Poly> polys(1);
polys[0] = poly;
cpolys = Clipping::getClipperPolygons(polys);
}
break;
case PolyInfill: // fill all polygons with their shrinked polys
{
vector< vector<Poly> > ipolys; // "shells"
for (uint i=0;i<tofillpolys.size();i++){
double parea = Clipping::Area(tofillpolys[i]);
// make first larger to get clip overlap
double firstshrink=0.5*infillDistance;
if (parea<0) firstshrink=-0.5*infillDistance;
vector<Poly> shrinked = Clipping::getOffset(tofillpolys[i],firstshrink);
vector<Poly> shrinked2 = Clipping::getOffset(shrinked,0.5*infillDistance);
for (uint i=0;i<shrinked2.size();i++)
shrinked2[i].cleanup(0.3*infillDistance);
ipolys.push_back(shrinked2);
//ipolys.insert(ipolys.end(),shrinked.begin(),shrinked.end());
double area = Clipping::Area(shrinked);
//cerr << "shr " <<parea << " - " <<area<< " - " << " : " <<endl;
//int shrcount =1;
int lastnumpolys=0;
while (shrinked.size()>0){
if (area*parea<0) break;
//cerr << "shr " <<parea << " - " <<area<< " - " << shrcount << " : " <<endl;
shrinked2 = Clipping::getOffset(shrinked,0.5*infillDistance);
for (uint i=0;i<shrinked2.size();i++)
shrinked2[i].cleanup(0.3*infillDistance);
ipolys.push_back(shrinked2);
//ipolys.insert(ipolys.end(),shrinked.begin(),shrinked.end());
lastnumpolys = shrinked.size();
shrinked = Clipping::getOffset(shrinked,-infillDistance);
for (uint i=0;i<shrinked.size();i++)
shrinked[i].cleanup(0.3*infillDistance);
area = Clipping::Area(shrinked);
//shrcount++;
}
// // remove last because they are too small
// ipolys.erase(ipolys.end()-lastnumpolys,ipolys.end());
}
vector<Poly> opolys;
for (uint i=0;i<ipolys.size();i++){
opolys.insert(opolys.end(),ipolys[i].begin(),ipolys[i].end());
}
cpolys = Clipping::getClipperPolygons(opolys);
//cerr << "cpolys " << cpolys.size() << endl;
}
break;
default:
cerr << "infill type " << type << " unknown "<< endl;
}
// save
//tid = omp_get_thread_num( );
//cerr << "thread "<<tid << " saving pattern " << endl;
struct pattern newPattern;
newPattern.type=type;
newPattern.angle=rotation;
newPattern.distance=infillDistance;
newPattern.cpolys=cpolys;
if (type != PolyInfill && type != ZigzagInfill) // can't save these
{
newPattern.Min=Min;
newPattern.Max=Max;
savedPatterns.push_back(newPattern);
//cerr << "saved pattern " << endl;
}
return newPattern.cpolys;
}
void hilbert(int level,int direction, double infillDistance, vector<Vector2d> &v)
{
//cerr <<"hilbert level " << level<< endl;
if (level==1) {
switch (direction) {
case LEFT:
move(RIGHT,infillDistance,v); /* move() could draw a line in... */
move(DOWN, infillDistance,v); /* ...the indicated direction */
move(LEFT, infillDistance,v);
break;
case RIGHT:
move(LEFT, infillDistance,v);
move(UP, infillDistance,v);
move(RIGHT,infillDistance,v);
break;
case UP:
move(DOWN, infillDistance,v);
move(RIGHT,infillDistance,v);
move(UP, infillDistance,v);
break;
case DOWN:
move(UP, infillDistance,v);
move(LEFT, infillDistance,v);
move(DOWN, infillDistance,v);
break;
} /* switch */
} else {
switch (direction) {
case LEFT:
hilbert(level-1,UP,infillDistance,v);
move(RIGHT,infillDistance,v);
hilbert(level-1,LEFT,infillDistance,v);
move(DOWN,infillDistance,v);
hilbert(level-1,LEFT,infillDistance,v);
move(LEFT,infillDistance,v);
hilbert(level-1,DOWN,infillDistance,v);
break;
case RIGHT:
hilbert(level-1,DOWN,infillDistance,v);
move(LEFT,infillDistance,v);
hilbert(level-1,RIGHT,infillDistance,v);
move(UP,infillDistance,v);
hilbert(level-1,RIGHT,infillDistance,v);
move(RIGHT,infillDistance,v);
hilbert(level-1,UP,infillDistance,v);
break;
case UP:
hilbert(level-1,LEFT,infillDistance,v);
move(DOWN,infillDistance,v);
hilbert(level-1,UP,infillDistance,v);
move(RIGHT,infillDistance,v);
hilbert(level-1,UP,infillDistance,v);
move(UP,infillDistance,v);
hilbert(level-1,RIGHT,infillDistance,v);
break;
case DOWN:
hilbert(level-1,RIGHT,infillDistance,v);
move(UP,infillDistance,v);
hilbert(level-1,DOWN,infillDistance,v);
move(LEFT,infillDistance,v);
hilbert(level-1,DOWN,infillDistance,v);
move(DOWN,infillDistance,v);
hilbert(level-1,LEFT,infillDistance,v);
break;
} /* switch */
} /* if */
}
int main (int argc, char ** argv)
{
int n, j, g, choice;
double p;
double** A;
int i=1;
while (i!=0)
{
clear();
printf("Menu principal : Polynome caractéristique, valeurs propres et vecteurs propres\n\n");
printf("Choisir le mode de saisie de la matrice :\n");
printf("1- Utiliser le générateur de matrices\n");
printf("0- Entrer manuellement les valeurs\n");
printf("Votre choix : ");
scanf("%d",&g);
clear();
if(g)
{
printf("MENU : GENERATION DE MATRICES\n\n");
printf("Choisir un type de matrice à générer :\n");
printf("1. Creuse à 70%%\n");
printf("2. A bord\n");
printf("3. Ding-Dong\n");
printf("4. Franc\n");
printf("5. Hilbert\n");
printf("6. KMS\n");
printf("7. Lehmer\n");
printf("8. Lotkin\n");
printf("9. Moler\n");
printf("Votre choix : ");
scanf("%d", &choice);
printf("Dimension : ");
scanf("%d", &n);
switch (choice)
{
case 1:
A=creuse70(n);
break;
case 2:
A=bord(n);
break;
case 3:
A=dingDong(n);
break;
case 4:
A=franc(n);
break;
case 5:
A=hilbert(n);
break;
case 6:
printf("Parametre p : ");
scanf("%lf", &p);
A=kms(n,p);
break;
case 7:
A=lehmer(n);
break;
case 8:
A=lotkin(n);
break;
case 9:
A=moler(n);
break;
}
// Déplacement de afficher matrice pour l'afficher au-dessus du menu de choix, ainsi elle est systématiquement affichée
}
else
{
printf("Matrice A :\n");
printf("Dimension : ");
scanf("%d",&n);
A=creerRemplirMatrice(n,n);
}
convertMattoLatex(A,n,n);
i=1;
while (i!=0 && i!=9)
{
clear();
printf("Matrice :\n");
afficherMatrice(A, n, n);
printf("\nQue voulez-vous faire ?\n");
printf("1- Méthode de Leverrier\n");
printf("2- Méthode de Leverrier améliorée\n");
printf("3- Méthode des Puissances Itérées\n");
printf("9- Nouvelle matrice (Menu principal)\n");
printf("0- Quitter\n");
printf("Votre choix : ");
scanf("%d", &i);
cleanBuffer(); //vidage buffer
clear();
switch (i)
{
case 1:
printf("Polynome caracteristique par Leverrier... \n");
leverrier(A,n);
hitToContinue();
break;
case 2:
printf("Polynome caracteristique par Leverrier améliorée ... \n");
leverrierA(A,n);
hitToContinue();
break;
case 3:
printf("Méthode des puissances itérées ... \n");
printf("Précision souhaitée : ");
scanf("%lf", &p);
cleanBuffer();
puissancesIt(A,n,p);
hitToContinue();
break;
}
}
//libération mémoire
for (j=0; j<n; j++)
{
free(A[j]);
}
free(A);
}
return 0;
}
int
main(int argc, char **argv)
{
int i,j,k; /* counters */
int ns=0; /* number of samples in input data */
int nwavelet=1024; /* number of samples in mother wavelet */
float base=0.0; /* base */
float first=0.0; /* first exponent */
float expinc=0.0; /* exponent increment */
float last=0.0; /* last exponent */
float exponent=0.0; /* each exponent */
float maxscale=0.0; /* maximum scale value */
float minscale=0.0; /* minimum scale value */
float x=0.0;
float dx=0.0; /* xvalues incr */
float xmin=0.0; /* last xvalues - first vval */
float xcenter=0.0; /* x value of center of wavelet */
float xmax=0.0; /* last xvalues - first vval */
float sigma=1.0; /* sharpening parameter */
float waveletinc=0.0; /* wavelet interval */
float fmin=0.0; /* min, max filt value (debug) */
float *xvalues=NULL; /* wavelet xvalues */
float **filt=NULL; /* filter used for each conv */
float *f=NULL; /* scratch for filter fliplr */
float *sucwt_buff=NULL; /* scratch for convolution */
float *scales=NULL; /* scales */
float *waveletsum=NULL; /* cumulative sum of wavelet */
float *rt=NULL; /* temp data storage */
float *qt=NULL; /* temp hilbert transformed data storage */
float **tmpdata=NULL; /* temp data storage */
int wtype=0; /* type of wavelet selected */
float *wavelet=NULL; /* pointer to data constituting the wavelet */
int verbose=0; /* verbose flag */
int *index=NULL; /* wavelet subscripts to use for filter */
int *nconv=NULL; /* length of each filter */
int nscales=0; /* number of scales */
int holder=0; /* =1 compute the Holder-Lipschitz regularity */
float divisor=1.0; /* divisor used in Holder exponent calculation*/
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get parameters */
if(!getparfloat("base",&base)) base = 10.;
if(!getparfloat("first",&first)) first = -1.0;
if(!getparfloat("expinc",&expinc)) expinc = 0.01;
if(!getparfloat("last",&last)) last = 1.5;
if(!getparint("wtype",&wtype)) wtype = 0;
if(!getparint("nwavelet",&nwavelet)) nwavelet = 1024;
if(!getparfloat("xmin",&xmin)) xmin = -20.0;
if(!getparfloat("xcenter",&xcenter)) xmin = 0.0;
if(!getparfloat("xmax",&xmax)) xmax = 20.0;
if(!getparfloat("sigma",&sigma)) sigma = 1.0;
if(!getparint("holder",&holder)) holder = 0;
if(!getparfloat("divisor",&divisor)) divisor = 1.0;
if(!getparint("verbose",&verbose)) verbose = 0;
if(verbose)
warn("base=%f, first=%f, expinc=%f, last=%f",base,first,expinc,last);
/* Allocate space */
xvalues = ealloc1float(nwavelet);
wavelet = ealloc1float(nwavelet);
memset((void *) xvalues, 0, nwavelet*FSIZE);
memset((void *) wavelet, 0, nwavelet*FSIZE);
/* Compute wavelet */
if (wtype == 0 ) { /* so far only Mex. Hat function */
MexicanHatFunction(nwavelet, xmin, xcenter,
xmax, sigma, wavelet);
} else {
err("%d type of wavelet not yet implemented",wtype);
}
/* wavelet increment */
waveletinc = (xmax - xmin)/(nwavelet - 1);
/* verbose warning */
if(verbose)
warn("xmin=%f, xmax=%f, nwavelet=%d, waveletinc=%f",
xmin,xmax,nwavelet,waveletinc);
/* form xvalues[] array */
for(i=0,x=xmin; i<nwavelet; ++i,x+=waveletinc) xvalues[i] = x;
xvalues[nwavelet-1] = xmax;
/* compute scales */
scales = ealloc1float(SHRT_MAX);
memset((void *) scales, 0, SHRT_MAX*FSIZE);
exponent = first;
x = 0;
nscales = 0;
minscale = pow(base,first);
maxscale = pow(base,last);
while(x <= maxscale) {
x = pow(base,exponent);
scales[nscales] = x;
exponent+=expinc;
++nscales;
if(nscales == SHRT_MAX)
err("Too many scales, change params and re-run\n");
}
--nscales;
/* Allocate space */
nconv = ealloc1int(nscales);
index = ealloc1int(nwavelet);
waveletsum = ealloc1float(nwavelet);
filt = ealloc2float(nwavelet,nscales);
f = ealloc1float(nwavelet);
/* Zero out arrays */
memset((void *) nconv, 0, nscales*ISIZE);
memset((void *) index, 0, nwavelet*ISIZE);
memset((void *) waveletsum, 0, nwavelet*FSIZE);
memset((void *) filt[0], 0, nwavelet*nscales*FSIZE);
memset((void *) f, 0, nwavelet*FSIZE);
/* Form difference of xvalues */
for(i=nwavelet-1; i>=0; --i)
xvalues[i] = xvalues[i] - xvalues[0];
dx = xvalues[1];
xmax = xvalues[nwavelet-1];
/* verbose warning */
if(verbose) {
warn("first xvalues=%f, last xvalues=%f",
xvalues[0],xvalues[nwavelet-1]);
warn("dx=%f, xmax=%f",dx,xmax);
}
/* waveletsum is cumulative sum of wavelet multipled by dx */
fmin = 0;
for(i=0; i<nwavelet; ++i) {
fmin += wavelet[i];
waveletsum[i] = fmin * dx;
}
/* Build filters from summed wavelet */
for(i=0; i<nscales; ++i) {
nconv[i] = 1 + (int)(scales[i] * xmax);
for(j=0; j<nconv[i]; ++j)
index[j] = 1 + j / (scales[i] * dx);
for(j=0; j<nconv[i]; ++j)
f[j] = waveletsum[index[j]-1];
/* flip left right */
for(j=0,k=nconv[i]-1; j<nconv[i]; ++j,--k)
filt[i][j] = f[k];
}
/* Verbose warning */
if(verbose) {
warn("Convolution Lengths");
for(i=0; i<nscales; ++i) warn("%d ",nconv[i]);
}
if(verbose) warn("%d scales will be used for transforms",nscales);
/* Get information from first trace */
if(!gettr(&tr))
err("Cannot get first trace\n");
ns = tr.ns;
/* Allocate temporary storage space */
rt = ealloc1float(ns);
qt = ealloc1float(ns);
tmpdata = ealloc2float(nscales,ns);
/* Zero out rt and qt */
memset((void *) rt, 0, ns*FSIZE);
memset((void *) qt, 0, ns*FSIZE);
/* Alloc sucwt_buffer for longest convolution */
sucwt_buff = ealloc1float(ns+nconv[nscales-1]+1);
do { /* main loop over traces */
outtr.d2 = waveletinc;
outtr.f2 = minscale;
memcpy((void *)&outtr,(const void *)&tr,HDRBYTES);
/* Apply filters to produce wavelet transform */
for(i=0; i<nscales; ++i) { /* loop over scales */
for(j=0; j<ns+nconv[nscales-1]+1; ++j)
sucwt_buff[j] = 0;
/* convolve wavelet with data */
conv(ns,0,tr.data,nconv[i],0,
filt[i],ns,0,sucwt_buff);
for(j=0; j<ns; ++j)
rt[j] = sucwt_buff[j+nconv[i]/2-1];
for(j=ns-1; j>0; --j)
rt[j] = rt[j] - rt[j-1];
for(j=0; j<ns; ++j)
rt[j] = -sqrt(scales[i]) * rt[j];
/* form the hilbert transform of rt */
hilbert(ns,rt,qt);
/* If not holder, then output envelope */
if (!holder) {
for (j=0 ; j<ns; ++j) {
outtr.data[j] = sqrt(rt[j]*rt[j]
+ qt[j]*qt[j]);
}
outtr.cdpt = i + 1;
puttr(&outtr);
} else {
/* compute the modulus */
for (j=0 ; j<ns; ++j) {
tmpdata[j][i] = sqrt(rt[j]*rt[j] + qt[j]*qt[j]);
}
}
}
if (holder) { /* compute the Holder regularity traces */
float *x;
float *y;
float lrcoeff[4];
x = ealloc1float(nscales);
y = ealloc1float(nscales);
/* Compute an estimate of the Lipschitz (Holder)
* regularity. Following Mallat (1992)
*
* ln | Wf(x,s)| < ln C + alpha * ln|s|
*
* alpha here is the Holder or Lipschitz exponent
* s is the length scale, and Wf(x,s) is f in the
* wavelet basis.
*
* Here we merely fit a straight line
* through the log-log graph of the of our wavelet
* transformed data and return the slope as
* the regularity measure.
*
*/
for ( j =0 ; j< ns ; ++j ) {
int icount=0;
x[0]=0;
for ( i = 1 ; i < nscales ; ++i ) {
/* We stay away from values that will make */
/* NANs in the output */
if ((i>1) &&
(tmpdata[j][i-1] - tmpdata[j][1] > 0.0)) {
y[icount] = log(ABS(tmpdata[j][i]
- tmpdata[j][1]));
x[icount] = log(scales[i]-scales[1]);
++icount;
}
}
--icount;
/* straight line fit, return slope */
if ((icount> 10) && (divisor==1.0) ) {
linear_regression(y, x, icount, lrcoeff);
/* lrcoeff[0] is the slope of the line */
/* which is the Holder (Lipschitz) */
/* exponent */
outtr.data[j] = lrcoeff[0];
} else if ((icount> 10) && (divisor>1.0) ) {
float maxalpha=0.0;
float interval=icount/divisor;
for ( k = interval; k < icount; k+=interval){
linear_regression(y, x, k, lrcoeff);
maxalpha = MAX(lrcoeff[0],maxalpha);
}
outtr.data[j] = maxalpha;
} else if ((icount < 10) && (divisor>=1.0)) {
outtr.data[j] = 0.0;
} else if ( divisor < 1.0 ) {
err("divisor = %f < 1.0!", divisor);
}
}
puttr(&outtr); /* output holder regularity traces */
}
} while(gettr(&tr));
return(CWP_Exit());
}
void hilbertcurve::init(int order) {
curve = hilbert(order);
iter = 0;
}
static void
doHilbert(FILE * const ifP,
unsigned int const clumpSize) {
/*----------------------------------------------------------------------------
Use hilbert space filling curve dithering
-----------------------------------------------------------------------------*/
/*
* This is taken from the article "Digital Halftoning with
* Space Filling Curves" by Luiz Velho, proceedings of
* SIGRAPH '91, page 81.
*
* This is not a terribly efficient or quick version of
* this algorithm, but it seems to work. - Graeme Gill.
* [email protected]
*
*/
struct pam graypam;
struct pam bitpam;
tuple ** grays;
tuple ** bits;
int end;
int *x,*y;
int sum;
grays = pnm_readpam(ifP, &graypam, PAM_STRUCT_SIZE(tuple_type));
bitpam = makeOutputPam(graypam.width, graypam.height);
bits = pnm_allocpamarray(&bitpam);
MALLOCARRAY(x, clumpSize);
MALLOCARRAY(y, clumpSize);
if (x == NULL || y == NULL)
pm_error("out of memory");
initHilbert(graypam.width, graypam.height);
sum = 0;
end = clumpSize;
while (end == clumpSize) {
unsigned int i;
/* compute the next cluster co-ordinates along hilbert path */
for (i = 0; i < end; i++) {
if (hilbert(&x[i],&y[i])==0)
end = i; /* we reached the end */
}
/* sum levels */
for (i = 0; i < end; i++)
sum += grays[y[i]][x[i]][0];
/* dither half and half along path */
for (i = 0; i < end; i++) {
unsigned int const row = y[i];
unsigned int const col = x[i];
if (sum >= graypam.maxval) {
bits[row][col][0] = 1;
sum -= graypam.maxval;
} else
bits[row][col][0] = 0;
}
}
pnm_writepam(&bitpam, bits);
pnm_freepamarray(bits, &bitpam);
pnm_freepamarray(grays, &graypam);
}
int
main(int argc, char **argv)
{
cwp_String mode; /* display: real, imag, amp, arg */
int imode=AMP; /* integer abbrev. for mode in switch */
register complex *ct; /* complex trace */
int nt; /* number of points on input trace */
float dt; /* sample spacing */
float *data; /* array of data from each trace */
float *hdata; /* array of Hilbert transformed data */
float unwrap; /* PI/unwrap=min dphase assumed to by wrap*/
int wint; /* n time sampling to window */
cwp_Bool seismic; /* is this seismic data? */
int ntout;
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
dt = ((double) tr.dt)/1000000.0;
ntout = nt + nt -1;
/* check to see if data type is seismic */
seismic = ISSEISMIC(tr.trid);
if (!seismic)
warn("input is not seismic data, trid=%d", tr.trid);
/* Get mode; note that imode is initialized to AMP */
if (!getparstring("mode", &mode)) mode = "amp";
if (STREQ(mode, "phase")) imode = ARG;
else if (STREQ(mode, "freq")) imode = FREQ;
else if (STREQ(mode, "bandwidth")) imode = BANDWIDTH;
else if (STREQ(mode, "normamp")) imode = NORMAMP;
else if (STREQ(mode, "freqw")) imode = FREQW;
else if (STREQ(mode, "thin")) imode = THIN;
else if (STREQ(mode, "fdenv")) imode = FENV;
else if (STREQ(mode, "sdenv")) imode = SENV;
else if (STREQ(mode, "q")) imode = Q;
else if (!STREQ(mode, "amp"))
err("unknown mode=\"%s\", see self-doc", mode);
/* getpar value of unwrap */
switch(imode) {
case FREQ:
if (!getparfloat("unwrap", &unwrap)) unwrap=1;
break;
case Q:
if (!getparfloat("unwrap", &unwrap)) unwrap=1;
break;
case FREQW:
if (!getparfloat("unwrap", &unwrap)) unwrap=1;
if (!getparint("wint", &wint)) wint=3;
break;
case THIN:
if (!getparfloat("unwrap", &unwrap)) unwrap=1;
if (!getparint("wint", &wint)) wint=3;
break;
case ARG:
if (!getparfloat("unwrap", &unwrap)) unwrap=0;
break;
}
/* allocate space for data and hilbert transformed data, cmplx trace */
data = ealloc1float(nt);
hdata = ealloc1float(nt);
ct = ealloc1complex(nt);
/* Loop over traces */
do {
register int i;
/* Get data from trace */
for (i = 0; i < nt; ++i) data[i] = tr.data[i];
/* construct quadrature trace with hilbert transform */
hilbert(nt, data, hdata);
/* build the complex trace */
for (i = 0; i < nt; ++i) ct[i] = cmplx(data[i],hdata[i]);
/* Form absolute value, phase, or frequency */
switch(imode) {
case AMP:
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
tr.data[i] = sqrt(re*re + im*im);
}
/* set trace id */
tr.trid = ENVELOPE;
break;
case ARG:
{
float *phase = ealloc1float(nt);
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
if (re*re+im*im) phase[i] = atan2(im, re);
else phase[i] = 0.0;
}
/* phase unwrapping */
/* default unwrap=0 for this mode */
if (unwrap!=0) unwrap_phase(nt, unwrap, phase);
/* write phase values to tr.data */
for (i = 0; i < nt; ++i) tr.data[i] = phase[i];
/* set trace id */
tr.trid = INSTPHASE;
}
break;
case FREQ:
{
float *phase = ealloc1float(nt);
float fnyq = 0.5 / dt;
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
if (re*re+im*im) {
phase[i] = atan2(im, re);
} else {
phase[i] = 0.0;
}
}
/* unwrap the phase */
if (unwrap!=0) unwrap_phase(nt, unwrap, phase);
/* compute freq(t)=dphase/dt */
differentiate(nt, 2.0*PI*dt, phase);
/* correct values greater nyquist frequency */
for (i=0 ; i < nt; ++i) {
if (phase[i] > fnyq)
phase[i] = 2 * fnyq - phase[i];
}
/* write freq(t) values to tr.data */
for (i=0 ; i < nt; ++i) tr.data[i] = phase[i];
/* set trace id */
tr.trid = INSTFREQ;
}
break;
case FREQW:
{
float fnyq = 0.5 / dt;
float *freqw = ealloc1float(nt);
float *phase = ealloc1float(nt);
float *envelop = ealloc1float(nt);
float *envelop2 = ealloc1float(nt);
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
if (re*re+im*im) {
phase[i] = atan2(im, re);
} else {
phase[i] = 0.0;
}
envelop[i] = sqrt(re*re + im*im);
}
/* unwrap the phase */
if (unwrap!=0) unwrap_phase(nt, unwrap, phase);
/* compute freq(t)=dphase/dt */
differentiate(nt, 2.0*PI*dt, phase);
/* correct values greater nyquist frequency */
for (i=0 ; i < nt; ++i) {
if (phase[i] > fnyq)
phase[i] = 2 * fnyq - phase[i];
envelop2[i]=envelop[i]*phase[i];
}
twindow(nt, wint, envelop);
twindow(nt, wint, envelop2);
/* correct values greater nyquist frequency */
for (i=0 ; i < nt; ++i) {
freqw[i] = (envelop[i] == 0.0) ? 0.0 :envelop2[i]/envelop[i];
}
/* write freq(t) values to tr.data */
for (i=0 ; i < nt; ++i) tr.data[i] = freqw[i];
/* set trace id */
tr.trid = INSTFREQ;
}
break;
case THIN:
{
float fnyq = 0.5 / dt;
float *phase = ealloc1float(nt);
float *freqw = ealloc1float(nt);
float *phase2 = ealloc1float(nt);
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
if (re*re+im*im) {
phase[i] = atan2(im, re);
} else {
phase[i] = 0.0;
}
}
/* unwrap the phase */
if (unwrap!=0) unwrap_phase(nt, unwrap, phase);
/* compute freq(t)=dphase/dt */
differentiate(nt, 2.0*PI*dt, phase);
/* correct values greater nyquist frequency */
for (i=0 ; i < nt; ++i) {
if (phase[i] > fnyq)
phase[i] = 2 * fnyq - phase[i];
phase2[i]= 2 * fnyq - phase[i];
}
/* Do windowing for Average Ins . Freq over wint*/
twindow(nt, wint, phase2);
for (i=0 ; i < nt; ++i) {
freqw[i] = phase[i] - phase2[i];
/* if (abs(freqw[i]) > fnyq)
freqw[i] = 2 * fnyq - freqw[i];
*/
/* write Thin-Bed(t) values to tr.data */
tr.data[i] = freqw[i];
}
/* set trace id */
tr.trid = INSTFREQ;
}
break;
case BANDWIDTH:
{
float *envelop = ealloc1float(nt);
float *envelop2 = ealloc1float(nt);
/* Bandwidth (Barnes 1992)
|d(envelope)/dt|
band =abs |--------------|
|2 PI envelope |
*/
for (i = 0; i < nt; ++i) {
float er = ct[i].r;
float em = ct[i].i;
envelop[i] = sqrt(er*er + em*em);
envelop2[i]=sqrt(er*er + em*em);
}
differentiate(nt, dt, envelop);
for (i = 0; i < ntout; ++i) {
if (2.0*PI*envelop2[i]!=0.0) {
tr.data[i] = ABS(envelop[i]/(2.0*PI*envelop2[i]));
} else {
tr.data[i]=0.0;
}
}
tr.trid = ENVELOPE;
}
break;
case NORMAMP:
{
float phase;
float *na = ealloc1float(nt);
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
if (re*re+im*im) phase = atan2(im, re);
else phase = 0.0;
na[i] = cos(phase);
}
for (i=0 ; i < nt; ++i) tr.data[i] = na[i];
/* set trace id */
tr.trid = INSTPHASE;
}
break;
case FENV:
{
float *amp = ealloc1float(nt);
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
amp[i] = sqrt(re*re + im*im);
}
/*conv(nt, 0, envelop, nt, 0, time, ntout, 0, ouput);*/
differentiate(nt, 2.0*PI*dt, amp);
for (i=0 ; i < nt; ++i) tr.data[i] = amp[i];
/* set trace id */
tr.trid = ENVELOPE;
}
break;
case SENV:
{
float *amp = ealloc1float(nt);
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
amp[i] = sqrt(re*re + im*im);
}
differentiate(nt, 2.0*PI*dt, amp);
differentiate(nt, 2.0*PI*dt, amp);
for (i=0 ; i < nt; ++i) tr.data[i] = amp[i];
/* set trace id */
tr.trid = ENVELOPE;
}
break;
case Q:
{
float *envelop = ealloc1float(nt);
float *envelop2 = ealloc1float(nt);
float *phase = ealloc1float(nt);
float fnyq = 0.5 / dt;
/* Banswith (Barnes 1992)
-PI Freq(t) d(envelope)/dt
band = --------------------------
envelope(t)
*/
for (i = 0; i < nt; ++i) {
float re = ct[i].r;
float im = ct[i].i;
envelop[i] = sqrt(re*re + im*im);
envelop2[i]=sqrt(re*re + im*im);
if (re*re+im*im) {
phase[i] = atan2(im, re);
} else {
phase[i] = 0.0;
}
}
/* get envelope diff */
differentiate(nt, dt, envelop);
/* unwrap the phase */
if (unwrap!=0) unwrap_phase(nt, unwrap, phase);
/* compute freq(t)=dphase/dt */
differentiate(nt, 2.0*PI*dt, phase);
for (i=0 ; i < nt; ++i) {
if (phase[i] > fnyq)
phase[i] = 2 * fnyq - phase[i];
}
for (i = 0; i < ntout; ++i) {
if (envelop[i]!=0.0)
tr.data[i] = -1*PI*phase[i]*envelop2[i]/envelop[i];
else
tr.data[i]=0.0;
}
tr.trid = INSTFREQ;
}
break;
default:
err("%s: mysterious mode=\"%s\"", __LINE__, mode);
}
tr.d1 = dt; /* for graphics */
puttr(&tr);
} while (gettr(&tr));
return(CWP_Exit());
}
