LoadFile.ts

    setlinearButton.onclick = function(){
        g.updateOptions( {logscale: false} );
        setlinearButton.disabled = true;
        setlogButton.disabled = false;
    }
    setlogButton.onclick = function(){
        g.updateOptions( {logscale: true} );
        setlinearButton.disabled = false;
        setlogButton.disabled = true;
    }
    setEnergyButton.onclick = function () { 
        calibrated = true;
        drawChart(pixel1, pixel2, 0, 55);
        box1.setAttribute("value", "0");
        box2.setAttribute("value", "55");
    }
    setChannelsButton.onclick = function () {
        calibrated = false;
        drawChart(pixel1, pixel2, 0, 55);
        box1.setAttribute("value", "-");
        box2.setAttribute("value", "-");
    }
    ExportGraphButton.onclick = function(){
        var img = document.getElementById("chartToImg");
        Dygraph.Export.asPNG(g, img);
        ExportGraphButton.href = img.src.replace('image/png','image/octet-stream');
    }
    
    SubmitRangeButton.onclick = function(){
        peackSelection(0, 0);
    }

    /*
    la funzione peakSelection riceve in input gli estremi dell'intervallo da
    rappresentare e lancia le funzioni drawImg e drawChart con l'intervallo dato
    */
    function peackSelection(xMinRange: number, xMaxRange: number){
        //se l'intervallo è [0, 0] significa che devo leggere dalle spinbox i
        //valori desiderati.
        if(xMinRange == 0 && xMaxRange == 0){
            xMinRange = box1.value;
            xMaxRange = box2.value;
        }
        //Aggiornamento variabili globali
        globalxMinRange = xMinRange;
        globalxMaxRange = xMaxRange;
        newOrigin = { xp: 0, yp: 0};
        rePrint = false;
        calibrated = true;
        //disegni di immagine e grafico
        drawImg({xp:0, yp:0}, {xp:xDim-1, yp:yDim-1}, globalxMinRange, globalxMaxRange);
        drawChart({xp:0, yp:0}, {xp:xDim-1, yp:yDim-1}, globalxMinRange, globalxMaxRange);
    }

    //mi metto in ascolto di uno zoom manuale sul grafico
    var grp = <HTMLButtonElement>document.getElementById("chart");
    grp.onclick = function(){
        var r: number[];
        r = g.xAxisRange();
        if(!calibrated){
            r[0] = Math.floor((((r[0] + 1) * a) - b) / 1000);
            r[1] = Math.floor((((r[1] + 1) * a) - b) / 1000);
        } else {
            r[0] = round3(r[0]);
            r[1] = round3(r[1]);
            box1.setAttribute("value", r[0].toString());
            box2.setAttribute("value", r[1].toString());
        }
        globalxMinRange = r[0];
        globalxMaxRange = r[1];
        drawImg(pixel1, pixel2, r[0], r[1]);
    }

    /*
    mi metto in ascolto della selezione di un elemento
    */
    elementSelect.onchange = function(){
        var element: string = document.getElementById("elementSelect").value;
        switch(element){
            //Ca 
            case "1":
                peackSelection(3.6, 3.8);
                box1.setAttribute("value", "3.60");
                box2.setAttribute("value", "3.80");
                break;
            //Pb
            case "2":
                peackSelection(10.4, 10.7);
                box1.setAttribute("value", "10.40");
                box2.setAttribute("value", "10.70");
                break;
            //Hg
            case "3":
                peackSelection(9.8, 10.15);
                box1.setAttribute("value", "9.80");
                box2.setAttribute("value", "10.15");
                break;
            //Fe
            case "4":
                peackSelection(6.3, 6.5);
                box1.setAttribute("value", "6.30");
                box2.setAttribute("value", "6.50");
                break;
            //Cu
            case "5":
                peackSelection(7.85, 8.2);
                box1.setAttribute("value", "7.85");
                box2.setAttribute("value", "8.20");
                break;
            //Zn
            case "6":
                peackSelection(8.5, 8.72);
                box1.setAttribute("value", "8.50");
                box2.setAttribute("value", "8.72"); 
                break;
            //Ti
            case "7":
                peackSelection(4.35, 4.65);
                box1.setAttribute("value", "4.35");
                box2.setAttribute("value", "4.65");
                break;
            //K
            case "8":
                peackSelection(3.2, 3.42);
                box1.setAttribute("value", "3.20");
                box2.setAttribute("value", "3.42");
                break;
            //Co
            case "9":
                peackSelection(6.8, 7.05);
                box1.setAttribute("value", "6.80");
                box2.setAttribute("value", "7.05");
                break;
            //default
            default:
                peackSelection(0, 55);
                box1.setAttribute("value", "0");
                box2.setAttribute("value", "55");
                break;
        }
    }
}


/*
la funzione prepara i dati per il grafico se è da disegnare completo
*/
function setDataForCompleteChart(){

    //creo un array di 16384 elementi con la somma dei conteggi di tutti i pixel
    //per ogni canale
    var dataForChart: number[] = new Array(16384);
    for(var i: number = 0; i < 16384; i++){
        dataForChart[i] = 0;
    }
    for(var i: number = 0; i < xDim; i++){
        for(var j: number = 0; j < yDim; j++){
            for(var k: number = 0; k < 16384; k++){
                dataForChart[k] += DataMatrix[i][j][k];
            }
        }
    }

    //riempio le stringhe con i dati per il grafico
    dataCompleteChart = "Channel,Counts\n";
    dataCompleteChartCalibrated = "Energy,Counts\n";
    for(var i: number = 0; i < 16348; i++){
        dataCompleteChart += (i+1) + "," + dataForChart[i] + "\n";
        dataCompleteChartCalibrated += round3(((i+1)*a-b)/1000) + "," +
            dataForChart[i] + "\n";
    }
}

function round3(val: number){
    return (Math.round(val*Math.pow(10,3))/Math.pow(10,3));
}


/*
La funzione findMax riceve in input la matrice e gli estremi della sottomatrice
di cui deve trovare il massimo
*/
function findMax(matrix: number[][], pixel1: coordinates, pixel2:coordinates){
    var max: number = 0;
    for(var i: number = pixel1.xp; i <= pixel2.xp; i++){
        for(var j: number = pixel1.yp; j <= pixel2.yp; j++){
            if(matrix[i][j] > max){
                max = matrix[i][j];
            }
        }
    }  
    return max;    
}


/*
la funzione findPosition definisce la posizione del cursore del mouse
relativa al canvas nel momento in cui avviene l'evento passato in input 
*/
function findPosition(event: any, pixel: coordinates){
    var scrollTOP: number = (document.documentElement.scrollTop) ? 
        document.documentElement.scrollTop : document.body.scrollTop;
    var scrollLEFT: number = (document.documentElement.scrollLeft) ? 
        document.documentElement.scrollLeft : document.body.scrollLeft;
    var allX: number = event.clientX+scrollLEFT;
    var allY: number = event.clientY+scrollTOP;
    var elParent: any = document.getElementById('myCanvas');
    var objX: number = 0, objY: number = 0;
    while (elParent){
        objX += elParent.offsetLeft;
        objY += elParent.offsetTop;
        elParent = elParent.offsetParent;
    }

    pixel.xp = Math.floor((allX-objX - 1) / realPixelDim ) + newOrigin.xp;
    pixel.yp = Math.floor((allY-objY - 1) / realPixelDim ) + newOrigin.yp;
}


/*
la funzione findPosDown memorizza la posizione del pixel cliccato mentre la
funzione findPosUp memorizza la posizione del pixel quando il mouse viene
rilasciato. Inoltre questa seconda funzione ordina le coordinate, poi, se è
stato richiesto uno zoom, ridisegna il canvas e aggiorna l'origine; in ogni caso
aggiorna il grafico.
*/
function findPosDown(event: any){
    findPosition(event, zPixel1);
}
function findPosUp(event: any){
    findPosition(event, zPixel2);
    //alert(zPixel1.xp + " " + zPixel1.yp + " " +zPixel2.xp + " " + zPixel2.yp);
    //alert(newOrigin.xp + " " + newOrigin.yp);
    //controllo che pixel1.xp < pixel2.xp e che pixel1.yp < pixel2.yp
    var tmp: number;
    if (zPixel1.xp > zPixel2.xp) {
        tmp = zPixel1.xp;
        zPixel1.xp = zPixel2.xp;
        zPixel2.xp = tmp;
    }
    if (zPixel1.yp > zPixel2.yp) {
        tmp = zPixel1.yp;
        zPixel1.yp = zPixel2.yp;
        zPixel2.yp = tmp;
    }
    //verifico che non sia stato cliccato un singolo punto perchè, se così
    //fosse, non dovrei aggiornare la mappa nè segnalare che c'è uno zoom
    if (zPixel1.xp != zPixel2.xp || zPixel1.yp != zPixel2.yp){
        newOrigin = {xp: zPixel1.xp, yp:zPixel1.yp};
        drawImg(zPixel1, zPixel2, globalxMinRange, globalxMaxRange);
    }
    drawChart(zPixel1, zPixel2, globalxMinRange, globalxMaxRange);

}

function sumVect(vect: number[], from: number, to: number){
    var sum: number = 0;
    for(var i: number = from; i < to; i++){
        sum += vect[i];
    }
    return sum;
}