
const fN=document.getElementById("kmitocet");
const aN=document.getElementById("amplituda");
const fM=document.getElementById("kmitocetM")
const aM=document.getElementById("amplitudaM");
const selectTyp=document.getElementById("typModulace");
const vyberPrubeh=document.getElementById("prubehModulacnihoSignalu");
const hloubkaModulace=document.getElementById("Hloubka");
const faze=document.getElementById("Faze");

const potlacenicko=document.getElementById("potlaceniNosne");




const FNIN= document.getElementById("fNosInput");
const ANIN= document.getElementById("aNosInput");
const FMIN= document.getElementById("fModInput");
const AMIN= document.getElementById("aModInput");
const HLIN= document.getElementById("HloubkaInput");



const vzorkovaciKmitocet=2048;
let kmitocetN=40;
let kmitocetM=1;
let ampN=1;
let ampM=1;
let hloubkaM=1;
let phase=0;
let cas=2;


let INFN;
let INAN;
let INFM;
let INAM;
let INHL;

let frequencies=[];
let times = [];
let spectrum1=[];
let data5=[];




    fN.addEventListener('input', function handleChange(event) {
    console.log(event.target.value);
    kmitocetN= Number(event.target.value);
    FNIN.value=kmitocetN;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum();


});

fM.addEventListener('input', function handleChange(event) {
    console.log(event.target.value);
    kmitocetM= Number(event.target.value);
    FMIN.value=kmitocetM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum();

});

aM.addEventListener('input', function handleChange(event) {
    console.log(event.target.value);
    ampM= Number(event.target.value);
    AMIN.value=ampM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()

});

aN.addEventListener("input",function handleChange(event){


    console.log(event.target.value);
    ampN=Number(event.target.value);
    ANIN.value=ampN;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()



})

hloubkaModulace.addEventListener("input", function handleChange(event){
    console.log(event.target.value);
    hloubkaM=Number(event.target.value);
    HLIN.value=hloubkaM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()


})



FNIN.addEventListener("input", function handleChange(event){

    INFN=Number(event.target.value);
    fN.value=INFN;
    kmitocetN=INFN;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()




})

FMIN.addEventListener("input", function handleChange(event){

    INFM=Number(event.target.value);
    fM.value=INFM;
    kmitocetM=INFM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()


})


AMIN.addEventListener("input", function handleChange(event){

    INAM=Number(event.target.value);
    aM.value=INAM;
    ampM=INAM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()


})

ANIN.addEventListener("input", function handleChange(event){

    INAN=Number(event.target.value);
    aN.value=INAN;
    ampN=INAN;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()



})

HLIN.addEventListener("input", function handleChange(event){

    INHL=Number(event.target.value);
    hloubkaModulace.value=INHL;
    hloubkaM=INHL;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()


})


let sinusN=[];
let hodnoty =[];

function sinusNosna() {

    sinusN=[];
    hodnoty =[];

    let pocetVzorku = Math.round(cas*vzorkovaciKmitocet);


    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i /vzorkovaciKmitocet;
        sinusN[i] = ampN * Math.cos(2 * Math.PI * kmitocetN * perioda);
    }


    for (let i = 0; i < sinusN.length; i++) {
        hodnoty.push([i / vzorkovaciKmitocet, sinusN[i]]);
    }
}


function zobrazNosnySignal() {

    sinusNosna();


    const data = [hodnoty];


    const options = {title: "Nosný signál",
        xaxis: {
            title: "Čas (s)",
            max:1,
            autoscale: true
        },
        yaxis: {
            title: "Amplituda",
            autoscale: true
        }

    };

    Flotr.draw(document.getElementById("nosnaGraf"),data,options);

}



let sinusM=[];
let hodnotySinM =[];
function sinus(){

    sinusM=[];
    hodnotySinM =[];

    let pocetVzorku = Math.round(cas*vzorkovaciKmitocet);




    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i /vzorkovaciKmitocet;
        sinusM[i] = ampM * Math.sin((2 * Math.PI * kmitocetM * perioda +phase));
    }


    for (let i = 0; i < sinusM.length; i++) {
        hodnotySinM.push([i / vzorkovaciKmitocet, sinusM[i]]);
    }
}



let obdelnikM=[];
let hodnotyObdelnik = [];
function obdelnik() {

    obdelnikM=[];
    hodnotyObdelnik = [];

    const vzorkyvPeriode = vzorkovaciKmitocet / kmitocetM;
    const pulVzorky = vzorkyvPeriode / 2;
    const pocetVzorku = Math.round(vzorkovaciKmitocet * cas);
    const radZaVzorek = 2 * Math.PI / vzorkovaciKmitocet;
    const posunFaze = phase / radZaVzorek;

    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i / vzorkyvPeriode;
        const relpozice = (((perioda * vzorkyvPeriode) + posunFaze) % vzorkyvPeriode) - pulVzorky;

        if (relpozice < 0) {
            obdelnikM[i] = ampM;
        } else {
            obdelnikM[i] = -ampM;
        }
    }


    for (let i = 0; i < obdelnikM.length; i++) {
        hodnotyObdelnik.push([i / vzorkovaciKmitocet, obdelnikM[i]]);
    }
}



let pilaM = [];
let hodnotyPila = [];


function pila() {

    pilaM = [];
    hodnotyPila = [];

    const vzorkyvPeriode = vzorkovaciKmitocet / kmitocetM;
    const pocetVzorku = Math.round(vzorkovaciKmitocet * cas);
    const radZaVzorek = 2 * Math.PI / vzorkovaciKmitocet;
    const posunFaze = phase / radZaVzorek;

    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i / vzorkyvPeriode;
        const relPozice = (((perioda * vzorkyvPeriode) + posunFaze) % vzorkyvPeriode);
        console.log(relPozice);
        pilaM[i] = ampM * (2 * (relPozice / vzorkyvPeriode) - 1);
    }


    for (let i = 0; i < pilaM.length; i++) {
        hodnotyPila.push([i / vzorkovaciKmitocet, pilaM[i]]);
    }
}
let selectFaze;

faze.addEventListener("change",function handleChange(event){

    selectFaze=Number(event.target.value)

    if (selectFaze===12){

        phase=0;

    }
    else if (selectFaze===13){

        phase=1/4*Math.PI;

    }
    else if (selectFaze===14){

        phase=1/2*Math.PI;

    }

    else if (selectFaze===15){

        phase=3/4*Math.PI;

    }

    else if (selectFaze===16){

        phase=Math.PI;

    }

    else if (selectFaze===17){

        phase=5/4*Math.PI;

    }

    else if (selectFaze===18){

        phase=3/2*Math.PI;

    }

    else if (selectFaze===19){

        phase=7/4*Math.PI;

    }

    else if (selectFaze===20){

        phase=2*Math.PI;

    }

    fftecko();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    zobrazModuloveSpektrum()

})










let Selekt3=4;


vyberPrubeh.addEventListener('change', function handleChange(event) {


    Selekt3 =Number(event.target.value);


    if (Selekt3 == 4) {

        sinus();


    }
    else if (Selekt3 ==5) {

        obdelnik();

    }


    else if (Selekt3 == 7) {

        pila();

    }


    zobrazModulacniSignal();
    zobrazVyslednySignal();
    zobrazModuloveSpektrum()

});




let modulovanySignal = [];
let hodnotyDSBFC = [];  // Array to store time-value pairs
let VstupnisignalDSB=[];
function DSBFC() {


    sinus();
    sinusNosna();
    obdelnik();
    pila();




    hodnotyDSBFC=[];
    VstupnisignalDSB=[];
    modulovanySignal = [];

    if(Selekt3==4){

        VstupnisignalDSB=sinusM;

    }

    else if(Selekt3==5){

        VstupnisignalDSB=obdelnikM;


    }

    else if(Selekt3==7){

        VstupnisignalDSB=pilaM;

    }


    console.log(VstupnisignalDSB);

    for (let i = 0; i < sinusN.length; i++) {
        modulovanySignal[i] = sinusN[i]+(hloubkaM * VstupnisignalDSB[i]* sinusN[i]/ampN);
        const cas1 = i / vzorkovaciKmitocet;
        hodnotyDSBFC.push([cas1, modulovanySignal[i]]);
    }

    console.log(hodnotyDSBFC);


}


let VstupDSBSC=[];
let hodnotyDSBSC = [];
let modulovanysignal2=[]
function DSBSC() {

    sinus();
    sinusNosna();
    pila();
    obdelnik();



    VstupDSBSC=[];
    modulovanysignal2=[];


    if(Selekt3==4){

        VstupDSBSC=sinusM;

    }

    else if(Selekt3==5){

        VstupDSBSC=obdelnikM;


    }



    else if(Selekt3==7){

        VstupDSBSC=pilaM;


    }




    hodnotyDSBSC=[];

    console.log(VstupDSBSC);
    console.log(sinusN);


    for (let i = 0; i < sinusN.length; i++) {
        modulovanysignal2[i] = hloubkaM * VstupDSBSC[i] * sinusN[i] / ampN;
        const cas1 = i / vzorkovaciKmitocet;
        hodnotyDSBSC.push([cas1,modulovanysignal2[i]]);
    }
    console.log(modulovanysignal2);
    console.log(hodnotyDSBSC);


}

let kmitocotovaOsa1=[];
let casovaosa1=[];
let modulovanySignal1=[];
let spectrum2=[];
let vysledek=[];
let newSpectrum=[];
let ssbfiltrovane=[];
let VstupSSB=[];

function ssb() {

    sinus();
    sinusNosna();
    pila();
    obdelnik();

    hodnotyssb = [];
    modulovanySignal1=[];
    VstupSSB=[];



    if(Selekt3==4){

        VstupSSB=sinusM;

    }

    else if(Selekt3==5){

        VstupSSB=obdelnikM;


    }



    else if(Selekt3==7){

        VstupSSB=pilaM;


    }



    for (let i = 0; i < sinusN.length; i++) {
        modulovanySignal1[i] = sinusN[i] + (hloubkaM * VstupSSB[i] * sinusN[i] / ampN);
        const cas1 = i / vzorkovaciKmitocet;
        hodnotyssb.push([cas1, modulovanySignal1[i]]);
    }

    casovaosa1=[];

    for (let i = 0; i < hodnotyssb.length; i++) {
        casovaosa1.push(hodnotyssb[i][1]);
    }

    console.log(casovaosa1); // check

    const fft2 = new FFT(casovaosa1.length, vzorkovaciKmitocet);
    fft2.forward(casovaosa1);

    kmitocotovaOsa1=[];

    for (let i = 0; i < hodnotyssb.length/2; i++) {
        kmitocotovaOsa1.push(i * vzorkovaciKmitocet / hodnotyssb.length);
    }

    spectrum2 = fft2.spectrum;

    const indexNosne = Math.round(kmitocetN/ (vzorkovaciKmitocet / casovaosa1.length));
    console.log(indexNosne);


    for (let i = indexNosne+1; i < spectrum2.length; i++) {
        spectrum2[i] = 0;
    }

    console.log(spectrum2);


    newSpectrum = new Float32Array(spectrum2.length * 2);
    for (let i = 0; i < spectrum2.length; i++) {
        newSpectrum[i] = spectrum2[i];
        newSpectrum[i + 1] = 0;
    }

    console.log(newSpectrum);


     vysledek = fft2.inverse(newSpectrum);

    ssbfiltrovane=[];

    console.log(vysledek);

    for (let i = 0; i < sinusN.length; i++) {
        const cas1 = i / vzorkovaciKmitocet;
        ssbfiltrovane.push([cas1, vysledek[i]]);
    }


}



let hodnotySSBSC=[];
let VstupSSBSC=[];
let spectrum3=[];
let casovaOsa2=[];
let kmitoctovaOsa2=[];
let newSpectrum2=[];
let vysledek2=[];
let ssbSCfiltrovane=[];

let modulovanySignal8=[];
function SSBSC() {


        sinus();
        sinusNosna();
        pila();
        obdelnik();

        hodnotySSBSC = [];
        VstupSSBSC=[];
        modulovanySignal8=[];


        if(Selekt3===4){

            VstupSSBSC=sinusM;

        }

        else if(Selekt3===5){

            VstupSSBSC=obdelnikM;


        }

        else if(Selekt3===7){

            VstupSSBSC=pilaM;

        }


        for (let i = 0; i < sinusN.length; i++) {
            modulovanySignal8[i] = hloubkaM * VstupSSBSC[i] * sinusN[i] / ampN;
            const cas1 = i / vzorkovaciKmitocet;
            hodnotySSBSC.push([cas1, modulovanySignal8[i]]);
        }

        console.log(hodnotySSBSC);

    casovaOsa2=[];

    for (let i = 0; i < hodnotySSBSC.length; i++) {
        casovaOsa2.push(hodnotySSBSC[i][1]);
    }

    console.log(casovaOsa2); // check

    const fft3 = new FFT(casovaOsa2.length, vzorkovaciKmitocet);
    fft3.forward(casovaOsa2);

    kmitoctovaOsa2=[];

    for (let i = 0; i < hodnotySSBSC.length/2; i++) {
        kmitoctovaOsa2.push(i * vzorkovaciKmitocet / hodnotySSBSC.length);
    }

    spectrum3 = fft3.spectrum;

    const indexNosne2 = Math.round(kmitocetN/ (vzorkovaciKmitocet / casovaOsa2.length));
    console.log(indexNosne2);


    for (let i = indexNosne2; i < spectrum3.length; i++) {
        spectrum3[i] = 0;
    }

    console.log(spectrum3);


    newSpectrum2 = new Float32Array(spectrum3.length * 2);
    for (let i = 0; i < spectrum3.length; i++) {
        newSpectrum2[i] = spectrum3[i];
        newSpectrum2[i + 1] = 0;
    }

    console.log(newSpectrum2);


    vysledek2 = fft3.inverse(newSpectrum2);

    ssbSCfiltrovane=[];

    console.log(vysledek2);

    for (let i = 0; i < sinusN.length; i++) {
        const cas1 = i / vzorkovaciKmitocet;
        ssbSCfiltrovane.push([cas1, vysledek2[i]]);
    }




}

let Selekt4=200;
let RC=0.3;

potlacenicko.addEventListener('change', function handleChange(event) {

    Selekt4 = Number(event.target.value);

    DSBRC();
    SSBRC();

    if (Selekt4===200){

        RC=0.3;

    }

    else if (Selekt4===201){

        RC=0.5;

    }

    else if (Selekt4===202){

        RC=0.8;

    }

    else if (Selekt4===203){

        RC=1;

    }

    console.log(RC);

    zobrazVyslednySignal();
    zobrazModuloveSpektrum()

});


let potlaceni;
let hodnotyDSBRC = [];
let VstupnisignalDSBRC = [];
let modulovanySignalRC = [];
    function DSBRC() {
    sinus();
    sinusNosna();
    obdelnik();
    pila();


        hodnotyDSBRC = [];
        VstupnisignalDSBRC = [];
        modulovanySignalRC = [];


    if (Selekt3 === 4) {

        VstupnisignalDSBRC = sinusM;
    }

    else if (Selekt3 === 5) {

        VstupnisignalDSBRC = obdelnikM;
    }
    else if (Selekt3 === 7) {

        VstupnisignalDSBRC = pilaM;
    }





        for (let i = 0; i < sinusN.length; i++) {
        potlaceni = 1 / (1 + RC * Math.PI * kmitocetN);
        modulovanySignalRC[i] = (sinusN[i]*potlaceni) + (hloubkaM * VstupnisignalDSBRC[i] * sinusN[i] / ampN);
        const cas1= i / vzorkovaciKmitocet;
        hodnotyDSBRC.push([cas1, modulovanySignalRC[i]]);
    }

    console.log(hodnotyDSBRC);
}


    let hodnotySSBRC=[];

    let modulovanySignal100=[];

    let VstupSSBRC=[];
    let casovaOsa3=[];
    let kmitoctovaOsa3=[];
    let spectrum5=[];
    let ssbRCfiltrovane=[];
    let vysledek3=[];
    let newSpectrum3=[];
function SSBRC(){



    sinus();
    sinusNosna();
    pila();
    obdelnik();

    hodnotySSBRC =[];
    modulovanySignal100=[];
    VstupSSBRC=[];



    if(Selekt3==4){

        VstupSSBRC=sinusM;

    }

    else if(Selekt3==5){

        VstupSSBRC=obdelnikM;


    }



    else if(Selekt3==7){

        VstupSSBRC=pilaM;


    }



    for (let i = 0; i < sinusN.length; i++) {
        potlaceni = 1 / (1 + RC * Math.PI * kmitocetN);
        modulovanySignal100[i] = (sinusN[i]* potlaceni) +( hloubkaM * VstupSSBRC[i] * sinusN[i] / ampN) ;
        const cas1 = i / vzorkovaciKmitocet;
        hodnotySSBRC.push([cas1, modulovanySignal100[i]]);
    }

    casovaOsa3=[];

    for (let i = 0; i < hodnotySSBRC.length; i++) {
        casovaOsa3.push(hodnotySSBRC[i][1]);
    }

    console.log(casovaOsa3); // check

    const fft5 = new FFT(casovaOsa3.length, vzorkovaciKmitocet);
    fft5.forward(casovaOsa3);

    kmitoctovaOsa3=[];

    for (let i = 0; i < hodnotySSBRC.length/2; i++) {
        kmitoctovaOsa3.push(i * vzorkovaciKmitocet / hodnotySSBRC.length);
    }

    spectrum5 = fft5.spectrum;

    const indexNosne3 = Math.round(kmitocetN/ (vzorkovaciKmitocet / casovaOsa3.length));
    console.log(indexNosne3);


    for (let i = indexNosne3+1; i < spectrum5.length; i++) {
        spectrum5[i] = 0;
    }

    console.log(spectrum5);


    newSpectrum3 = new Float32Array(spectrum5.length * 2);
    for (let i = 0; i < spectrum5.length; i++) {
        newSpectrum3[i] = spectrum5[i];
        newSpectrum3[i + 1] = 0;
    }

    console.log(newSpectrum3);


    vysledek3 = fft5.inverse(newSpectrum3);

    ssbRCfiltrovane=[];

    console.log(vysledek);

    for (let i = 0; i < sinusN.length; i++) {
        const cas1 = i / vzorkovaciKmitocet;
        ssbRCfiltrovane.push([cas1, vysledek3[i]]);
    }




}






let  hodnotyModulacni=[];
function zobrazModulacniSignal() {

    sinus();
    obdelnik();
    pila();


    hodnotyModulacni=[];

    if (Selekt3 === 4){


        hodnotyModulacni=hodnotySinM;

    }

    else if (Selekt3 === 5){


        hodnotyModulacni=hodnotyObdelnik;

    }


    else if (Selekt3 == 7){


        hodnotyModulacni=hodnotyPila;

    }


    const data2 = [hodnotyModulacni
    ];

    const options2 = {title: "Modulační signál",
        xaxis: {
            title: "čas (s)",
            max:1,
            autoscale: true
        },
        yaxis: {
            title: "Amplituda",
            autoscale: true
        }

    };

    Flotr.draw(document.getElementById("modulacniGraf"),data2,options2);

}




let Selekt1=1;

selectTyp.addEventListener('change', function handleChange(event) {




    Selekt1 =Number(event.target.value);


    if (Selekt1 === 1) {

    DSBFC();


    }
    else if (Selekt1 === 2) {

    DSBSC();

    }
    else if (Selekt1 === 3) {


    ssb();

    }

    else if (Selekt1 ===40) {

    SSBSC();

    }

    else if (Selekt1 ===41) {

        DSBRC();

    }
    else if (Selekt1 ===42) {

        SSBRC();

    }


    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    zobrazModuloveSpektrum()

});








let hodnotyVysledne=[];
function zobrazVyslednySignal() {

    DSBFC();
    DSBSC();
    ssb();
    SSBSC();
    DSBRC();
    SSBRC();


    hodnotyVysledne=[];

    if(Selekt1===1){

        hodnotyVysledne=hodnotyDSBFC;

    }



    else if(Selekt1===2){

        hodnotyVysledne=hodnotyDSBSC;

    }


    else  if(Selekt1===3){

        hodnotyVysledne=ssbfiltrovane;
    }

    else if(Selekt1===40){

        hodnotyVysledne=ssbSCfiltrovane;
    }

    else if(Selekt1===41){

        hodnotyVysledne=hodnotyDSBRC;
    }

    else if(Selekt1===42){

        hodnotyVysledne=ssbRCfiltrovane;
    }



    const data3 = [hodnotyVysledne];
    const options3 = {title: "Signál po provedení amplitudové modulace",
        xaxis: {
            title: "čas (s)",
            max:2,
            autoscale: true
        },
        yaxis: {
            title: "Amplituda",
            autoscale: true
        }

    };

    console.log(data3)

    Flotr.draw(document.getElementById("VyslednyGraf"), data3, options3);

}



zobrazNosnySignal();
zobrazModulacniSignal();
zobrazVyslednySignal();



let spectrum=[];
let casovaOsa4=[];
let kmitoctovaOsa4=[];
function fftecko() {

    DSBFC();
    DSBSC();
    ssb();
    SSBSC();
    DSBRC();
    SSBRC();


    hodnotyVysledne = [];

    if (Selekt1 === 1) {

        hodnotyVysledne = hodnotyDSBFC;

    } else if (Selekt1 === 2) {

        hodnotyVysledne = hodnotyDSBSC;

    }

    else if (Selekt1 === 3) {

        hodnotyVysledne = ssbfiltrovane;

    } else if (Selekt1 === 40) {

        hodnotyVysledne = ssbSCfiltrovane;

    }

    else if (Selekt1 === 41) {

        hodnotyVysledne = hodnotyDSBRC;

    }

    else if (Selekt1 === 42) {

        hodnotyVysledne = ssbRCfiltrovane;

    }


    casovaOsa4 = [];

    for (let i = 0; i < hodnotyVysledne.length; i++) {
        casovaOsa4.push(hodnotyVysledne[i][1]);
    }

    console.log(casovaOsa4); // check

    const fft = new DFT(casovaOsa4.length, vzorkovaciKmitocet);
    fft.forward(casovaOsa4);


    spectrum = fft.spectrum;

    console.log(newSpectrum)

    if (Selekt1 === 3) {

        spectrum = newSpectrum;
    } else if (Selekt1 === 40) {

        spectrum = newSpectrum2;
    }
 else if (Selekt1 === 42) {

    spectrum = newSpectrum3;
}


    spectrum1 = Array.prototype.slice.call(spectrum);

    kmitoctovaOsa4 = [];

    for (let i = 0; i < hodnotyVysledne.length / 2; i++) {
        kmitoctovaOsa4.push(i * vzorkovaciKmitocet / hodnotyVysledne.length);
    }

    console.log(kmitoctovaOsa4); // check
    console.log(casovaOsa4);

}



function zobrazModuloveSpektrum() {




    data5=[];
    fftecko();

    for (let i = 0; i < kmitoctovaOsa4.length; i++) {
        data5.push([kmitoctovaOsa4[i], spectrum1[i]]);
    }

    const options4 = {


        title:"Modulové spektrum výsledného signálu",
        bars: {
            show: true,
            barWidth: 0.2,
        },

        xaxis: {

            min:0,
            max:100,
        },


        yaxis: {
            autoscale:true,
        }

    };

    Flotr.draw(document.getElementById("ModuloveSpektrum"),[data5], options4);

}


zobrazModuloveSpektrum();