View_Scanner.cpp

// ScannerView.cpp : implementation file
//

#include "stdafx.h"
#include "NovacMasterProgram.h"
#include "View_Scanner.h"
#include "Meteorology/MeteorologicalData.h"
#include "Configuration/Configuration.h"
#include "UserSettings.h"

extern CMeteorologicalData g_metData;      // <-- The metereological data
extern CConfigurationSetting g_settings;   // <-- The scanner/network settings
extern CUserSettings g_userSettings;       // <-- The users preferences

// CView_Scanner dialog
using namespace DlgControls;
using namespace Graph;
using namespace novac;

void DDX_Text_Formatted(CDataExchange* pDX, int nIDC, double& value, LPCTSTR lpszOutFormat = _T("%f"), LPCTSTR lpszInFormat = _T("%lf"));

// General method for rescaling a CGraphCtrl which is bounded inside a CStatic (owned by a window...)
void ResizeGraphControl(CGraphCtrl& controlToResize, CStatic& boundingFrame, CWnd* owningWindow)
{
    CRect boundingFramClientRegion;
    boundingFrame.GetWindowRect(&boundingFramClientRegion);
    owningWindow->ScreenToClient(boundingFramClientRegion);

    CRect plotControlClientRegion;
    controlToResize.GetWindowRect(&plotControlClientRegion);
    boundingFrame.ScreenToClient(plotControlClientRegion);

    plotControlClientRegion.right = boundingFramClientRegion.Width() - 20;
    plotControlClientRegion.bottom = boundingFramClientRegion.Height() - 10;

    controlToResize.MoveWindow(plotControlClientRegion);
    controlToResize.InvalidateCtrl();
}

IMPLEMENT_DYNAMIC(CView_Scanner, CPropertyPage)
CView_Scanner::CView_Scanner()
    : CPropertyPage(CView_Scanner::IDD)
{
    m_evalDataStorage = nullptr;
    m_commDataStorage = nullptr;
    m_scannerIndex = 0;
    m_serial.Format("");
    m_siteName.Format("");

    windDirection = g_metData.defaultWindField.GetWindDirection();
    windSpeed = g_metData.defaultWindField.GetWindSpeed();
    plumeHeight = g_metData.defaultWindField.GetPlumeHeight();
}

CView_Scanner::~CView_Scanner()
{
}

void CView_Scanner::DoDataExchange(CDataExchange* pDX)
{
    CPropertyPage::DoDataExchange(pDX);
    DDX_Control(pDX, IDC_STATIC_COLUMN, m_lastScanFrame);
    DDX_Control(pDX, IDC_STATIC_FLUX, m_todayScanFrame);

    // The status lights
    DDX_Control(pDX, IDC_STATUS_LIGHT, m_statusLight);
    DDX_Control(pDX, IDC_COMMSTATUS, m_commStatusLight);
    DDX_Control(pDX, IDC_LABEL_EVALSTATUS, m_statusEval);
    DDX_Control(pDX, IDC_LABEL_SCANNERSTATUS, m_statusScanner);

    // the meteorology things
    DDX_Text_Formatted(pDX, IDC_EDIT_PLUMEHEIGHT, plumeHeight, "%.1lf");
    DDX_Text_Formatted(pDX, IDC_EDIT_WINDDIRECTION, windDirection, "%.1lf");
    DDX_Text_Formatted(pDX, IDC_EDIT_WINDSPEED, windSpeed, "%.1lf");

    DDX_Control(pDX, IDC_BUTTON_SET_WINDFIELD, m_setButton);
    DDX_Control(pDX, IDC_EDIT_WINDDIRECTION, m_windDirection);
    DDX_Control(pDX, IDC_EDIT_WINDSPEED, m_windSpeed);
    DDX_Control(pDX, IDC_EDIT_PLUMEHEIGHT, m_plumeHeight);
    DDX_Control(pDX, IDC_LABEL_WINDDIRECTION, m_labelWindDirection);
    DDX_Control(pDX, IDC_LABEL_WINDSPEED, m_labelWindSpeed);
    DDX_Control(pDX, IDC_LABEL_PLUMEHEIGHT, m_labelPlumeHeight);

    // The information about the scanner
    DDX_Control(pDX, IDC_CONFINFO_SERIAL, m_infoSerial);
    DDX_Control(pDX, IDC_CONFINFO_COMPASS, m_infoCompass);
    DDX_Control(pDX, IDC_CONFINFO_LATITUDE, m_infoLatitude);
    DDX_Control(pDX, IDC_CONFINFO_LONGITUDE, m_infoLongitude);

    // The information about the last scan
    DDX_Control(pDX, IDC_SCANINFO_STARTTIME, m_scanInfo_Starttime);
    DDX_Control(pDX, IDC_SCANINFO_STOPTIME, m_scanInfo_StopTime);
    DDX_Control(pDX, IDC_SCANINFO_DATE, m_scanInfo_Date);

    DDX_Control(pDX, IDC_SCANINFO_EXPTIME, m_scanInfo_ExpTime);
    DDX_Control(pDX, IDC_SCANINFO_NSPEC, m_scanInfo_NumSpec);
    DDX_Control(pDX, IDC_LABEL_COLUMN_COLOR, m_legend_ColumnColor);
    DDX_Control(pDX, IDC_LABEL_PEAK_INTENSITY_COLOR, m_legend_PeakIntensity);
    DDX_Control(pDX, IDC_LABEL_FIT_INTENSITY_COLOR, m_legend_FitIntensity);
}


BEGIN_MESSAGE_MAP(CView_Scanner, CPropertyPage)
    // Messages from other parts of the program
    ON_MESSAGE(WM_EVAL_SUCCESS, OnEvaluatedScan)
    ON_MESSAGE(WM_EVAL_FAILURE, OnEvaluatedScan)
    ON_MESSAGE(WM_SCANNER_RUN, OnUpdateEvalStatus)
    ON_MESSAGE(WM_SCANNER_SLEEP, OnUpdateEvalStatus)
    ON_MESSAGE(WM_SCANNER_NOT_CONNECT, OnUpdateEvalStatus)
    ON_MESSAGE(WM_NEW_WINDFIELD, OnUpdateWindParam)

    // Commands from the user
    ON_COMMAND(IDC_BUTTON_SET_WINDFIELD, OnBnClickedButtonSetWindfield)
    ON_WM_SIZE()
END_MESSAGE_MAP()


// CView_Scanner message handlers

void CView_Scanner::SetLayout() {
    const int rightMargin = 25;

    CRect thisClientRegion;
    GetWindowRect(thisClientRegion);
    this->ScreenToClient(thisClientRegion);

    // Adjust the width of the column frame
    if (this->m_lastScanFrame.m_hWnd != nullptr) {
        CRect lastScanFrameClientRegion;
        m_lastScanFrame.GetWindowRect(&lastScanFrameClientRegion);
        this->ScreenToClient(lastScanFrameClientRegion);

        lastScanFrameClientRegion.right = thisClientRegion.right - rightMargin;
        m_lastScanFrame.MoveWindow(lastScanFrameClientRegion);

        ResizeGraphControl(m_lastScanPlot, m_lastScanFrame, this);
    }

    // Adjust the width of the flux frame
    if (this->m_todayScanFrame.m_hWnd != nullptr) {
        CRect fluxFrameClientRegion;
        m_todayScanFrame.GetWindowRect(&fluxFrameClientRegion);
        this->ScreenToClient(fluxFrameClientRegion);

        fluxFrameClientRegion.right = thisClientRegion.right - rightMargin;
        m_todayScanFrame.MoveWindow(fluxFrameClientRegion);

        ResizeGraphControl(m_todayPlot, m_todayScanFrame, this);
    }
}

BOOL CView_Scanner::OnInitDialog()
{
    int height, width;
    CPropertyPage::OnInitDialog();
    Common common;
    CString columnAxisLabel, fluxAxisLabel;

    // Fix the layout first
    //	SetLayout();

    // Load the bitmaps
    m_greenLight.LoadBitmap(MAKEINTRESOURCE(IDB_GREEN_LIGHT));
    m_yellowLight.LoadBitmap(MAKEINTRESOURCE(IDB_YELLOW_LIGHT));
    m_redLight.LoadBitmap(MAKEINTRESOURCE(IDB_RED_LIGHT));

    // Initialize the unit to use
    if (g_userSettings.m_columnUnit == UNIT_MOLEC_CM2) {
        columnAxisLabel.Format("%s [ppmm]", (LPCTSTR)common.GetString(AXIS_COLUMN));
    }
    else {
        columnAxisLabel.Format("%s [molec/cm²]", (LPCTSTR)common.GetString(AXIS_COLUMN));
    }


    // initialize the last scan plot (columns)
    CRect rect;
    m_lastScanFrame.GetWindowRect(rect);
    height = rect.bottom - rect.top;
    width = rect.right - rect.left;
    rect.top = 20; rect.bottom = height - 10;
    rect.left = 10; rect.right = width - 10;
    m_lastScanPlot.Create(WS_VISIBLE | WS_CHILD, rect, &m_lastScanFrame);
    m_lastScanPlot.SetSecondYUnit(common.GetString(AXIS_INTENSITY));
    m_lastScanPlot.SetSecondRangeY(0, 4096, 0);
    m_lastScanPlot.SetXUnits(common.GetString(AXIS_ANGLE));
    m_lastScanPlot.SetYUnits(columnAxisLabel);
    m_lastScanPlot.SetBackgroundColor(RGB(0, 0, 0));
    m_lastScanPlot.SetPlotColor(RGB(255, 0, 0));
    m_lastScanPlot.SetGridColor(RGB(255, 255, 255));
    m_lastScanPlot.SetRange(-90, 90, 0, 0, 100, 0);

    // The legend
    m_legend_ColumnColor.SetBackgroundColor(RGB(255, 0, 0));
    m_legend_PeakIntensity.SetBackgroundColor(RGB(255, 255, 255));
    m_legend_FitIntensity.SetBackgroundColor(RGB(255, 255, 0));
    m_legend_ColumnColor.SetWindowText("");
    m_legend_PeakIntensity.SetWindowText("");
    m_legend_FitIntensity.SetWindowText("");

    // initialize today's plot (may be flux or columns)
    m_todayScanFrame.GetWindowRect(rect);
    height = rect.bottom - rect.top;
    width = rect.right - rect.left;
    rect.top = 20; rect.bottom = height - 10;
    rect.left = 10; rect.right = width - 10;
    m_todayPlot.Create(WS_VISIBLE | WS_CHILD, rect, &m_todayScanFrame);
    m_todayPlot.SetXUnits(common.GetString(AXIS_UTCTIME));
    m_todayPlot.SetXAxisNumberFormat(FORMAT_DATETIME);
    m_todayPlot.SetYUnits("Column");
    m_todayPlot.EnableGridLinesX(true);
    m_todayPlot.SetPlotColor(RGB(255, 255, 255));
    m_todayPlot.SetGridColor(RGB(255, 255, 255));
    m_todayPlot.SetBackgroundColor(RGB(0, 0, 0));
    m_todayPlot.SetMinimumRangeY(1.0);
    m_todayPlot.SetRangeY(0, 100, 0);
    SetTodayRange();

    // Enable the tool tips
    if (!m_toolTip.Create(this)) {
        TRACE0("Failed to create tooltip control\n");
    }
    m_toolTip.AddTool(&m_windDirection, IDC_EDIT_WINDDIRECTION);
    m_toolTip.AddTool(&m_labelWindDirection, IDC_EDIT_WINDDIRECTION);
    m_toolTip.AddTool(&m_windSpeed, IDC_EDIT_WINDSPEED);
    m_toolTip.AddTool(&m_labelWindSpeed, IDC_EDIT_WINDSPEED);
    m_toolTip.AddTool(&m_plumeHeight, IDC_EDIT_PLUMEHEIGHT);
    m_toolTip.AddTool(&m_labelPlumeHeight, IDC_EDIT_PLUMEHEIGHT);
    m_toolTip.AddTool(&m_setButton, IDC_BUTTON_SET_WINDFIELD);
    m_toolTip.AddTool(&m_todayPlot, IDC_FLUX_PLOT);
    m_toolTip.AddTool(&m_infoSerial, IDC_CONFINFO_SERIAL);
    m_toolTip.AddTool(&m_infoCompass, IDC_CONFINFO_COMPASS);
    m_toolTip.AddTool(&m_infoLatitude, IDC_CONFINFO_LATITUDE);
    m_toolTip.AddTool(&m_infoLongitude, IDC_CONFINFO_LONGITUDE);
    m_toolTip.AddTool(&m_scanInfo_Starttime, IDC_SCANINFO_STARTTIME);
    m_toolTip.AddTool(&m_scanInfo_StopTime, IDC_SCANINFO_STOPTIME);
    m_toolTip.AddTool(&m_scanInfo_Date, IDC_SCANINFO_DATE);
    m_toolTip.AddTool(&m_scanInfo_ExpTime, IDC_SCANINFO_EXPTIME);
    m_toolTip.AddTool(&m_scanInfo_NumSpec, IDC_SCANINFO_NSPEC);
    m_toolTip.AddTool(&m_statusLight, IDC_STATUS_LIGHT);
    m_toolTip.AddTool(&m_commStatusLight, IDC_COMMSTATUS);
    m_toolTip.AddTool(&m_statusEval, IDC_STATUS_LIGHT);
    m_toolTip.AddTool(&m_statusScanner, IDC_COMMSTATUS);

    m_toolTip.SetMaxTipWidth(INT_MAX);
    m_toolTip.Activate(TRUE);

    // Update the plot...
    if (g_settings.scanner[m_scannerIndex].plotColumn) {
        m_todayPlot.SetCircleRadius(1);
        DrawColumnDay();
    }
    else {
        m_todayPlot.SetLineWidth(2);
        DrawFlux();
    };

    // If the wind-field has been set automatically, then show it to the user
    CWindField windField;
    CDateTime	dt;
    if (0 == g_metData.GetWindField(m_serial, dt, windField)) {
        this->windSpeed = windField.GetWindSpeed();
        this->windDirection = windField.GetWindDirection();
        this->plumeHeight = windField.GetPlumeHeight();
        UpdateData(FALSE);
    }

    return TRUE;  // return TRUE unless you set the focus to a control
    // EXCEPTION: OCX Property Pages should return FALSE
}

void CView_Scanner::SetTodayRange() {
    // set time range for last day plot
    struct tm* tm;
    time_t endtime;
    time(&endtime);
    tm = gmtime(&endtime);
    time_t starttime = endtime - 60 * 60 * 24;
    m_todayPlot.SetRangeX(starttime, endtime, 0);
}

void CView_Scanner::DrawColumn() {
    Common common;
    // Strings used for the saving of images
    CString sDate, sTime, imageFileName, lastImageFileName, directory, latestInfoFileName;

    const int BUFFER_SIZE = 1000;
    double time[BUFFER_SIZE], column[BUFFER_SIZE], columnError[BUFFER_SIZE], badColumn[BUFFER_SIZE], angle[BUFFER_SIZE], peakSat[BUFFER_SIZE], fitSat[BUFFER_SIZE];
    double maxAngle, minAngle, maxColumn, minColumn;

    // remove the old plot
    m_lastScanPlot.CleanPlot();

    // Set the unit of the plot
    if (g_userSettings.m_columnUnit == UNIT_PPMM)
        m_lastScanPlot.SetYUnits("Column [ppmm]");
    else if (g_userSettings.m_columnUnit == UNIT_MOLEC_CM2)
        m_lastScanPlot.SetYUnits("Column [molec/cm²]");

    // Get the data
    int dataLength = m_evalDataStorage->GetColumnData(m_serial, column, columnError, BUFFER_SIZE);
    dataLength = min(dataLength, m_evalDataStorage->GetAngleData(m_serial, angle, BUFFER_SIZE));
    dataLength = min(dataLength, m_evalDataStorage->GetIntensityData(m_serial, peakSat, fitSat, BUFFER_SIZE, false));

    // If there's no data then don't draw anything
    if (dataLength <= 0)
        return;

    // Get the ranges for the data
    m_evalDataStorage->GetAngleRange(m_serial, minAngle, maxAngle);
    m_evalDataStorage->GetColumnRange(m_serial, minColumn, maxColumn);

    // Copy the bad-columns to the 'badColumn' - array
    m_evalDataStorage->GetBadColumnData(m_serial, badColumn, BUFFER_SIZE);

    // Check if this is a fixed-angle or wind-measurement of if its a normal scan
    m_isTimeSeries = fabs(maxAngle - minAngle) < 1e-2;
    int nRepetitions = 0;
    for (int i = 2; i < dataLength; ++i) {
        if (angle[i] == angle[i - 2]) {
            ++nRepetitions;
        }
    }
    if (nRepetitions > 5) {
        m_isTimeSeries = true;
    }

    // Check data ranges
    minColumn = min(minColumn, 0);
    if (fabs(maxColumn - minColumn) < 1E-2) {
        minColumn -= 1;
        maxColumn += 1;
    }
    // set limits on the data ranges
    maxColumn = min(maxColumn, 1e22);
    minColumn = max(minColumn, -1e22);

    // get the offset
    double offset = m_evalDataStorage->GetOffset(m_serial);

    // and the plume centre
    double	plumeCentre = m_evalDataStorage->GetPlumeCentre(m_serial);

    // remove the offset
    for (int i = 0; i < dataLength; ++i) {
        column[i] = column[i] - offset;
        if (fabs(badColumn[i]) > 1.0) {
            badColumn[i] -= offset;
        }
    }

    minColumn -= offset;
    maxColumn -= offset;
    minColumn = (minColumn < 0) ? (minColumn * 1.25) : (minColumn / 1.5);
    maxColumn = (maxColumn > 0) ? (maxColumn * 1.25) : (maxColumn / 1.5);

    // Convert the saturation ratios to percent
    for (int i = 0; i < dataLength; ++i) {
        fitSat[i] *= 100.0;
        peakSat[i] *= 100.0;
    }

    // Set the range for the graph
    if (m_isTimeSeries) {
        // wind speed measurement?
        // Get the timeOfDay for each spectrum
        m_evalDataStorage->GetTimeData(m_serial, time, BUFFER_SIZE);

        m_lastScanPlot.SetRange(Min(time, dataLength), Max(time, dataLength), 1, minColumn, maxColumn, 0);
        m_lastScanPlot.SetXUnits(common.GetString(AXIS_TIMEOFDAY));
        m_lastScanPlot.SetXAxisNumberFormat(Graph::FORMAT_TIME);
    }
    else {
        // normal scan
        m_lastScanPlot.SetRange(minAngle, maxAngle, 1, minColumn, maxColumn, 0);
        m_lastScanPlot.SetXUnits(common.GetString(AXIS_ANGLE));
        m_lastScanPlot.SetXAxisNumberFormat(Graph::FORMAT_GENERAL);
    }

    // If we know the dynamic range for the spectrometer, 
    //	set the plot to show saturation-levels instead of intensities
    m_lastScanPlot.SetSecondRangeY(0, 100, 0, false);
    m_lastScanPlot.SetSecondYUnit(common.GetString(AXIS_SATURATION));

    // draw the columns
    if (m_isTimeSeries) {
        m_lastScanPlot.XYPlot(time, column, dataLength, CGraphCtrl::PLOT_FIXED_AXIS | CGraphCtrl::PLOT_CONNECTED);

        // draw the peak saturation
        m_lastScanPlot.SetCircleColor(RGB(255, 255, 255));
        m_lastScanPlot.DrawCircles(time, peakSat, dataLength, CGraphCtrl::PLOT_SECOND_AXIS);

        // draw the fit-saturation
        m_lastScanPlot.SetCircleColor(RGB(255, 255, 0));
        m_lastScanPlot.DrawCircles(time, fitSat, dataLength, CGraphCtrl::PLOT_SECOND_AXIS);
    }
    else {
        // All the column-values
        m_lastScanPlot.SetPlotColor(RGB(255, 0, 0));
        m_lastScanPlot.BarChart(angle, column, columnError, dataLength, CGraphCtrl::PLOT_FIXED_AXIS | CGraphCtrl::PLOT_BAR_SHOW_X);

        // The bad column-values
        m_lastScanPlot.SetPlotColor(RGB(128, 0, 0));
        m_lastScanPlot.BarChart(angle, badColumn, dataLength, CGraphCtrl::PLOT_FIXED_AXIS | CGraphCtrl::PLOT_BAR_SHOW_X);

        // draw the peak saturation
        m_lastScanPlot.SetCircleColor(RGB(255, 255, 255));
        m_lastScanPlot.DrawCircles(angle, peakSat, dataLength, CGraphCtrl::PLOT_SECOND_AXIS);

        // draw the fit-saturation
        m_lastScanPlot.SetCircleColor(RGB(255, 255, 0));
        m_lastScanPlot.DrawCircles(angle, fitSat, dataLength, CGraphCtrl::PLOT_SECOND_AXIS);

        // Draw the plume-centre position (if known);
        if (plumeCentre > -200) {
            m_lastScanPlot.DrawLine(Graph::VERTICAL, plumeCentre, RGB(255, 255, 0), Graph::STYLE_DASHED);
        }
    }

    // If the user wants to save the graph, then do so
    if (g_settings.webSettings.publish) {
        sDate.Format("%02d%02d%02d", m_lastScanStart.year % 1000, m_lastScanStart.month, m_lastScanStart.day);
        sTime.Format("%02d%02d", m_lastScanStart.hour, m_lastScanStart.minute);

        if (strlen(g_settings.webSettings.localDirectory) > 0) {
            // The directory where to store the images
            directory.Format("%s\\%s", (LPCTSTR)g_settings.webSettings.localDirectory, (LPCTSTR)sDate);
            if (CreateDirectoryStructure(directory)) {
                ShowMessage("Could not create storage-directory for images. No image stored.");
                return; // failed to create directory, no idea to try to continue...
            }

            // The name of the image-file
            imageFileName.Format("%s\\%s_%s_%s_%1d%s",
                (LPCTSTR)directory,
                (LPCTSTR)m_serial,
                (LPCTSTR)sDate,
                (LPCTSTR)sTime,
                m_lastScanChannel,
                (LPCTSTR)g_settings.webSettings.imageFormat);

            // Save the column-plot
            m_lastScanPlot.SaveGraph(imageFileName);

            // Also save a copy of the column-plot to an additional directory, if this is
            //		the latest file received
            if (m_lastScanStart == m_mostRecentScanStart) {
                lastImageFileName.Format("%s\\%s\\", (LPCTSTR)g_settings.webSettings.localDirectory, (LPCTSTR)m_serial);
                if (CreateDirectoryStructure(lastImageFileName)) {
                    ShowMessage("Could not create storage-directory for images. No image stored.");
                    return; // failed to create directory, no idea to try to continue...
                }
                lastImageFileName.AppendFormat("Image.jpg");
                m_lastScanPlot.SaveGraph(lastImageFileName);
            }

            // Make a small file which contains the name of the last file generated
            latestInfoFileName.Format("%s\\LastColumnGraph_%s.txt", (LPCTSTR)g_settings.webSettings.localDirectory, (LPCTSTR)m_serial);
            FILE* f = fopen(latestInfoFileName, "w");
            if (f != nullptr) {
                fprintf(f, "%s\n", (LPCTSTR)imageFileName);
                fclose(f);
            }

            // if the user wants to call an external script, then do so
            if (strlen(g_settings.externalSetting.imageScript) > 2) {
                ExecuteScript_Image(imageFileName);
            }
        }
    }
}

/** For single direction measurements, do not plot flux.  Instead, plot columns for the day. */
void CView_Scanner::DrawColumnDay() {
    Common common;

    // variables
    const int BUFFER_SIZE = 10000;
    double time[BUFFER_SIZE], column[BUFFER_SIZE], columnError[BUFFER_SIZE], badColumn[BUFFER_SIZE], peakSat[BUFFER_SIZE], fitSat[BUFFER_SIZE];
    double maxColumn, minColumn;

    // Get the data
    int dataLength = m_evalDataStorage->GetColumnData(m_serial, column, columnError, BUFFER_SIZE, true);
    dataLength = min(dataLength, m_evalDataStorage->GetIntensityData(m_serial, peakSat, fitSat, BUFFER_SIZE, true));

    // If there's no data then don't draw anything
    if (dataLength <= 0)
        return;

    // remove the old plot
    m_todayPlot.CleanPlot();

    // Set the unit of the plot
    if (g_userSettings.m_columnUnit == UNIT_PPMM)
        m_todayPlot.SetYUnits("Column [ppmm]");
    else if (g_userSettings.m_columnUnit == UNIT_MOLEC_CM2)
        m_todayPlot.SetYUnits("Column [molec/cm²]");

    // Get the ranges for the data
    m_evalDataStorage->GetColumnRange(m_serial, minColumn, maxColumn, true);

    // Check data ranges
    minColumn = min(minColumn, 0);
    if (fabs(maxColumn - minColumn) < 1E-2) {
        minColumn -= 1;
        maxColumn += 1;
    }
    // set limits on the data ranges
    maxColumn = min(maxColumn, 1e22);
    minColumn = max(minColumn, -1e22);

    // Copy the bad-columns to the 'badColumn' - array
    m_evalDataStorage->GetBadColumnData(m_serial, badColumn, BUFFER_SIZE, true);

    // get the offset
    double offset = m_evalDataStorage->GetOffset(m_serial);

    // remove the offset
    for (int i = 0; i < dataLength; ++i) {
        column[i] = column[i] - offset;
        if (fabs(badColumn[i]) > 1.0) {
            badColumn[i] -= offset;
        }
    }

    minColumn -= offset;
    maxColumn -= offset;
    minColumn = (minColumn < 0) ? (minColumn * 1.25) : (minColumn / 1.5);
    maxColumn = (maxColumn > 0) ? (maxColumn * 1.25) : (maxColumn / 1.5);

    // Convert the saturation ratios to percent
    for (int i = 0; i < dataLength; ++i) {
        fitSat[i] *= 100.0;
        peakSat[i] *= 100.0;
    }

    m_todayPlot.SetRangeY(minColumn, maxColumn, 0);
    SetTodayRange();

    // If we know the dynamic range for the spectrometer, 
    //	set the plot to show saturation-levels instead of intensities
    double maxIntensity = m_evalDataStorage->GetDynamicRange(m_serial);
    if (maxIntensity > 0) {
        m_todayPlot.SetSecondRangeY(0, 100, 0, false);
        m_todayPlot.SetSecondYUnit(common.GetString(AXIS_SATURATION));
    }
    else {
        m_todayPlot.SetSecondRangeY(0, 4096, 0, false);
        m_todayPlot.SetSecondYUnit(common.GetString(AXIS_INTENSITY));
    }

    m_evalDataStorage->GetTimeData(m_serial, time, BUFFER_SIZE, true);

    // draw the columns
    m_todayPlot.SetCircleColor(RGB(255, 0, 0));
    m_todayPlot.XYPlot(time, column, dataLength, CGraphCtrl::PLOT_FIXED_AXIS | CGraphCtrl::PLOT_CIRCLES);

    // draw the peak saturation
    m_todayPlot.SetCircleColor(RGB(255, 255, 255));
    m_todayPlot.DrawCircles(time, peakSat, dataLength, CGraphCtrl::PLOT_SECOND_AXIS);

    // draw the fit-saturation
    m_todayPlot.SetCircleColor(RGB(255, 255, 0));
    m_todayPlot.DrawCircles(time, fitSat, dataLength, CGraphCtrl::PLOT_SECOND_AXIS);

    // If the user wants to save the graph, then do so
    if (g_settings.webSettings.publish) {

        // Strings used for the saving of images
        CString sDate, sTime, imageFileName, lastImageFileName, directory, latestInfoFileName;

        sDate.Format("%02d%02d%02d", m_lastScanStart.year % 1000, m_lastScanStart.month, m_lastScanStart.day);

        if (strlen(g_settings.webSettings.localDirectory) > 0) {
            // The directory where to store the images
            directory.Format("%s\\%s", (LPCTSTR)g_settings.webSettings.localDirectory, (LPCTSTR)sDate);
            if (CreateDirectoryStructure(directory)) {
                ShowMessage("Could not create storage-directory for images. No image stored.");
                return; // failed to create directory, no idea to try to continue...
            }

            // The name of the image-file
            imageFileName.Format("%s\\%s_%s_%1d%s",
                (LPCTSTR)directory,
                (LPCTSTR)m_serial,
                (LPCTSTR)sDate,
                m_lastScanChannel,
                (LPCTSTR)g_settings.webSettings.imageFormat);

            // Save the column-plot
            m_todayPlot.SaveGraph(imageFileName);

            // Also save a copy of the column-plot to an additional directory, if this is
            //		the latest file received
            if (m_lastScanStart == m_mostRecentScanStart) {
                lastImageFileName.Format("%s\\%s\\", (LPCTSTR)g_settings.webSettings.localDirectory, (LPCTSTR)m_serial);
                if (CreateDirectoryStructure(lastImageFileName)) {
                    ShowMessage("Could not create storage-directory for images. No image stored.");
                    return; // failed to create directory, no idea to try to continue...
                }
                lastImageFileName.AppendFormat("Image.jpg");
                m_todayPlot.SaveGraph(lastImageFileName);
            }

            // Make a small file which contains the name of the last file generated
            latestInfoFileName.Format("%s\\DayColumnGraph_%s.txt", (LPCTSTR)g_settings.webSettings.localDirectory, (LPCTSTR)m_serial);
            FILE* f = fopen(latestInfoFileName, "w");
            if (f != nullptr) {
                fprintf(f, "%s\n", (LPCTSTR)imageFileName);
                fclose(f);
            }

            // if the user wants to call an external script, then do so
            if (strlen(g_settings.externalSetting.imageScript) > 2) {
                ExecuteScript_Image(imageFileName);
            }
        }
    }
}

void CView_Scanner::DrawFlux() {
    double maxFlux;
    const int BUFFER_SIZE = 200;
    double allFluxes[BUFFER_SIZE];
    double tid[BUFFER_SIZE];
    int fluxOk[BUFFER_SIZE];
    double goodFluxes[BUFFER_SIZE];
    double badFluxes[BUFFER_SIZE];
    double goodTime[BUFFER_SIZE];
    double badTime[BUFFER_SIZE];
    int nGoodFluxes = 0;
    int nBadFluxes = 0;
    CString fluxAxisLabel;
    Common common;

    // Get the data
    int dataLength = m_evalDataStorage->GetFluxData(m_serial, tid, allFluxes, fluxOk, BUFFER_SIZE);

    // sort the data into good values and bad values
    for (int k = 0; k < dataLength; ++k) {
        if (fluxOk[k]) {
            goodFluxes[nGoodFluxes] = allFluxes[k];
            goodTime[nGoodFluxes] = tid[k];
            ++nGoodFluxes;
        }
        else {
            badFluxes[nBadFluxes] = allFluxes[k];
            badTime[nBadFluxes] = tid[k];
            ++nBadFluxes;
        }
    }

    // remove the old plot
    m_todayPlot.CleanPlot();

    // Set the unit of the plot
    if (g_userSettings.m_fluxUnit == UNIT_TONDAY) {
        fluxAxisLabel.Format("%s [ton/day]", (LPCTSTR)common.GetString(AXIS_FLUX));
    }
    else {
        fluxAxisLabel.Format("%s [kg/s]", (LPCTSTR)common.GetString(AXIS_FLUX));
    }
    m_todayPlot.SetYUnits(fluxAxisLabel);

    // If there's no data, don't draw anything
    if (dataLength == 0)
        return;

    // Get the ranges for the flux data
    maxFlux = Max(allFluxes, dataLength);

    // set the range for the plot
    m_todayPlot.SetRangeY(0, maxFlux, 1);
    SetTodayRange();

    // First draw the bad values, then the good ones
    m_todayPlot.SetCircleColor(RGB(150, 150, 150));
    m_todayPlot.XYPlot(badTime, badFluxes, nBadFluxes, CGraphCtrl::PLOT_FIXED_AXIS | CGraphCtrl::PLOT_CIRCLES);

    m_todayPlot.SetCircleColor(RGB(255, 255, 255));
    m_todayPlot.XYPlot(goodTime, goodFluxes, nGoodFluxes, CGraphCtrl::PLOT_FIXED_AXIS | CGraphCtrl::PLOT_CIRCLES);


    // If the user wants to save the graph, then do so
    if (g_settings.webSettings.publish) {
        CString sDate;
        Common::GetDateText(sDate);
        if (strlen(g_settings.webSettings.localDirectory) > 0) {
            CString fileName;
            fileName.Format("%s\\flux_%s_%s%s",
                (LPCTSTR)g_settings.webSettings.localDirectory,
                (LPCTSTR)m_serial,
                (LPCTSTR)sDate,
                (LPCTSTR)g_settings.webSettings.imageFormat);
            m_todayPlot.SaveGraph(fileName);
        }
    }
}

LRESULT CView_Scanner::OnEvaluatedScan(WPARAM wParam, LPARAM lParam) {
    // Update the screen
    OnUpdateEvalStatus(wParam, lParam);
    OnUpdateWindParam(wParam, lParam);

    if (lParam != NULL) {
        Evaluation::CScanResult* result = (Evaluation::CScanResult*)lParam;
        delete result;
    }

    return 0;
}

LRESULT CView_Scanner::OnUpdateEvalStatus(WPARAM wParam, LPARAM lParam) {
    CString txt;

    // The status for the evaluation
    SPECTROMETER_STATUS status;

    // The status for the communication
    COMMUNICATION_STATUS comm_status;

    // Get the status
    m_evalDataStorage->GetStatus(m_serial, status);
    comm_status = (COMMUNICATION_STATUS)(m_commDataStorage->GetStatus(m_serial));

    // update the status light
    switch (status) {
    case STATUS_RED:          m_statusLight.SetBitmap((HBITMAP)m_redLight); break;
    case STATUS_GREEN:        m_statusLight.SetBitmap((HBITMAP)m_greenLight); break;
    case STATUS_YELLOW:       m_statusLight.SetBitmap((HBITMAP)m_yellowLight); break;
    default:                  m_statusLight.SetBitmap((HBITMAP)m_yellowLight); break;
    }
    switch (comm_status) {
    case COMM_STATUS_RED:     m_commStatusLight.SetBitmap((HBITMAP)m_redLight); break;
    case COMM_STATUS_GREEN:   m_commStatusLight.SetBitmap((HBITMAP)m_greenLight); break;
    case COMM_STATUS_YELLOW:  m_commStatusLight.SetBitmap((HBITMAP)m_yellowLight); break;
    default:                  m_commStatusLight.SetBitmap((HBITMAP)m_yellowLight); break;
    }

    Common common;
    if (g_settings.scanner[m_scannerIndex].gps.m_latitude == 0) {
        printf("ojsan");
    }
    // update the configuration info
    txt.Format("%s", (LPCTSTR)g_settings.scanner[m_scannerIndex].spec[0].serialNumber);
    this->SetDlgItemText(IDC_CONFINFO_SERIAL, txt);
    txt.Format("%.1lf [deg]", fmod(g_settings.scanner[m_scannerIndex].compass, 360.0f));
    this->SetDlgItemText(IDC_CONFINFO_COMPASS, txt);
    txt.Format("%.5lf", g_settings.scanner[m_scannerIndex].gps.m_latitude);
    this->SetDlgItemText(IDC_CONFINFO_LATITUDE, txt);
    txt.Format("%.5lf", g_settings.scanner[m_scannerIndex].gps.m_longitude);
    this->SetDlgItemText(IDC_CONFINFO_LONGITUDE, txt);
    if (fabs(g_settings.scanner[m_scannerIndex].coneAngle - 90.0) < 1e-2) {
        // flat scanner
        txt.Format("%s", (LPCTSTR)common.GetString(STR_FLAT));
    }
    else {
        // Cone-scanner
        txt.Format("%s,%.0lf [deg]", (LPCTSTR)common.GetString(STR_CONE), g_settings.scanner[m_scannerIndex].coneAngle);
    }
    this->SetDlgItemText(IDC_CONFINFO_CONEORFLAT, txt);

    // Update the info about the last scan
    if (lParam != NULL) {
        Evaluation::CScanResult* result = (Evaluation::CScanResult*)lParam;
        CDateTime startTime;
        result->GetSkyStartTime(startTime);
        CDateTime stopTime = result->GetSpectrumInfo(result->GetEvaluatedNum() - 1).m_stopTime;

        txt.Format("%02d:%02d:%02d", startTime.hour, startTime.minute, startTime.second);
        SetDlgItemText(IDC_SCANINFO_STARTTIME, txt);

        txt.Format("%02d:%02d:%02d", stopTime.hour, stopTime.minute, stopTime.second);
        SetDlgItemText(IDC_SCANINFO_STOPTIME, txt);

        txt.Format("%04d.%02d.%02d", startTime.year, startTime.month, startTime.day);
        SetDlgItemText(IDC_SCANINFO_DATE, txt);

        txt.Format("%d [ms]", result->GetSpectrumInfo(0).m_exposureTime);
        SetDlgItemText(IDC_SCANINFO_EXPTIME, txt);

        txt.Format("%d", result->GetSpectrumInfo(0).m_numSpec);
        SetDlgItemText(IDC_SCANINFO_NSPEC, txt);

        // Remember the time when the last shown scan started
        m_lastScanStart.year = startTime.year;
        m_lastScanStart.month = startTime.month;
        m_lastScanStart.day = startTime.day;
        m_lastScanStart.hour = startTime.hour;
        m_lastScanStart.minute = startTime.minute;
        m_lastScanStart.second = startTime.second;
        if (m_mostRecentScanStart < m_lastScanStart) {
            m_mostRecentScanStart = m_lastScanStart;
        }

        // Also remember the channel that the last collected scan used
        m_lastScanChannel = result->GetSpectrumInfo(0).m_channel;
    }

    // update the last scan plot
    DrawColumn();

    // update today's plot
    if (g_settings.scanner[m_scannerIndex].plotColumn) {
        DrawColumnDay();
    }
    else {
        DrawFlux();
    }

    return 0;
}

LRESULT CView_Scanner::OnUpdateWindParam(WPARAM wParam, LPARAM lParam) {
    CWindField wind;
    CDateTime dt;

    // Get the current time
    dt.SetToNow();
    dt.Increment(_timezone); // convert from local-time to GMT

    // Get the wind-field for this scanner...
    if (g_metData.GetWindField(m_serial, dt, wind)) {
        // if the wind field could not be found, use the standard values
        wind = g_metData.defaultWindField;
    }

    // Update the screen
    plumeHeight = wind.GetPlumeHeight();
    windDirection = wind.GetWindDirection();
    windSpeed = wind.GetWindSpeed();
    UpdateData(FALSE);

    return 0;
}

void CView_Scanner::OnBnClickedButtonSetWindfield()
{
    CString message, curVolcano;
    unsigned int it;
    static time_t now = 0, lastTime = 0;

    // Get the user defined wind field
    UpdateData(TRUE);

    CWindField wf;
    wf.SetPlumeHeight(plumeHeight, MET_USER);
    wf.SetWindDirection(windDirection, MET_USER);
    wf.SetWindSpeed(windSpeed, MET_USER);

    // Set the wind field
    g_metData.SetWindField(m_serial, wf);

    // get the time now
    lastTime = now;
    time(&now);
    if (difftime(now, lastTime) < 5 * 60) {
        // If the user has pressed this button two (or more) times
        //  within five minutes, then interpret this as he/she wanted
        //  to set the wind-field for all instruments on the first
        //  click and to set the wind-field for this instrument on
        //  the following clicks...

        // tell the user which wind field has been changed
        message.Format("Set windfield @ %s to: ", (LPCTSTR)m_siteName);

        // tell the user what the wind field is 
        message.AppendFormat("%.1lf m/s, %.1lf degrees, plume @ %.0lf m above the scanner",
            wf.GetWindSpeed(), wf.GetWindDirection(), wf.GetPlumeHeight());

    }
    else {
        // It's quite some time since the user pressed this button
        //  last time. Set the wind-field for all instruments and not just for 
        //	the currently shown...

        // The wind-field should be the same for all instruments at this volcano, 
        //			find out which other instruments look at the same volcano and set the
        //			wind-field for them too.
        curVolcano.Format(g_settings.scanner[m_scannerIndex].volcano);
        for (it = 0; it < g_settings.scannerNum; ++it) {
            if (it == m_scannerIndex)
                continue;
            if (Equals(curVolcano, g_settings.scanner[it].volcano))
                g_metData.SetWindField(g_settings.scanner[it].spec[0].serialNumber, wf);
        }

        // tell the user which wind field has been changed
        message.Format("Set windfield @ %s to: ", (LPCTSTR)curVolcano);

        // tell the user what the wind field is 
        message.AppendFormat("%.1lf m/s, %.1lf degrees, plume @ %.0lf m above the scanner",
            wf.GetWindSpeed(), wf.GetWindDirection(), wf.GetPlumeHeight());
    }

    ShowMessage(message);
}


BOOL CView_Scanner::PreTranslateMessage(MSG* pMsg)
{
    m_toolTip.RelayEvent(pMsg);

    return CPropertyPage::PreTranslateMessage(pMsg);
}

BOOL CView_Scanner::OnSetActive()
{
    // Redraw the screen
    OnUpdateEvalStatus(NULL, NULL);
    OnUpdateWindParam(NULL, NULL);
    return CPropertyPage::OnSetActive();
}

void CView_Scanner::ExecuteScript_Image(const CString& imageFile) {
    CString command, filePath, directory;

    // The file to execute
    filePath.Format("%s", (LPCTSTR)g_settings.externalSetting.imageScript);

    // The directory of the executable file
    directory.Format(filePath);
    Common::GetDirectory(directory);

    // The parameters to the script
    command.Format("%s", (LPCTSTR)imageFile);

    // Call the script
    int result = (int)ShellExecute(nullptr, "open", filePath, command, directory, SW_SHOW);

    // Check the return-code if there was any error...
    if (result > 32)
        return;
    switch (result) {
    case 0:	break;// out of memory
    case ERROR_FILE_NOT_FOUND:	MessageBox("Specified script-file not found");	break;	// file not found
    case ERROR_PATH_NOT_FOUND:	MessageBox("Specified script-file not found");	break;	// path not found
    case ERROR_BAD_FORMAT:		break;	// 
    case SE_ERR_ACCESSDENIED:break;
    case SE_ERR_ASSOCINCOMPLETE:break;
    case SE_ERR_DDEBUSY:break;
    case SE_ERR_DDEFAIL:break;
    case SE_ERR_DDETIMEOUT:break;
    case SE_ERR_DLLNOTFOUND:break;
    case SE_ERR_NOASSOC:break;
    case SE_ERR_OOM:break;
    case SE_ERR_SHARE:break;
    }
    // don't try again to access the file
    g_settings.externalSetting.imageScript.Format("");

}
void CView_Scanner::OnSize(UINT nType, int cx, int cy)
{
    CPropertyPage::OnSize(nType, cx, cy);

    this->SetLayout();
}

void DDX_Text_Formatted(CDataExchange* pDX, int nIDC, double& value, LPCTSTR lpszOutFormat, LPCTSTR lpszInFormat)
{
    CString temp;

    if (!pDX->m_bSaveAndValidate)
        temp.Format(lpszOutFormat, value);

    DDX_Text(pDX, nIDC, temp);

    if (pDX->m_bSaveAndValidate) {
        int ret = sscanf(temp, lpszInFormat, &value);
    }
}