RouteDlg.cpp

// RouteDlg.cpp : implementation file
//

#undef min
#undef max

#include "stdafx.h"
#include "DMSpec.h"
#include "RouteDlg.h"
#include "Flux/Traverse.h"
#include "Flux/WindField.h"
#include "WindFieldDlg.h"
#include "SourceSelectionDlg.h"
#include <algorithm>

#include <Math.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CRouteDlg dialog

using namespace Flux;


CRouteDlg::CRouteDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CRouteDlg::IDD, pParent)
  , m_curLatitude(0)
  , m_selectedDisplay(0)
{
	m_showSource = 0;
	m_showColumnOption = 0;
	for(int i = 0; i < MAX_FLUX_LOGFILES; ++i)
		m_useWindField[i] = false;

	m_pointSize = 3;

	m_initalSelection = 0;

	m_windFieldColor	= RGB(255, 255, 255);
	m_circlesColor		= RGB(0, 255, 0);

	m_showScale = 1;
}


void CRouteDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CRouteDlg)
	// NOTE: the ClassWizard will add DDX and DDV calls here
	DDX_Text(pDX, IDC_SRC_LAT_EDIT, m_srcLat);
	DDX_Text(pDX, IDC_SRC_LON_EDIT, m_srcLon);

	DDX_Control(pDX, IDC_CHECK_SHOW_SOURCE,			m_showSourceCheck);
	DDX_Control(pDX, IDC_CHECK_CALC_DISTANCE,		m_calcDistance);

	DDX_Control(pDX, IDC_FRAME_LANDMARKS,			m_frameLandmarks);

	DDX_Radio(pDX, IDC_SHOW_COLUMN,					m_selectedDisplay);
	DDX_Control(pDX, IDC_EVALLOG_LIST,				m_evalLogList);

	DDX_Control(pDX, IDC_ROUTEDLG_POINTSIZESPIN,	m_pointSizeSpin);
	DDX_Control(pDX, IDC_ROUTDLG_POINTSIZEEDIT,		m_pointSizeEdit);

	DDX_Control(pDX, IDC_CHECK_SHOW_INTERPOLATED_WINDFIELD, m_showInterpolatedWindField);

	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CRouteDlg, CDialog)
	//{{AFX_MSG_MAP(CRouteDlg)
	ON_MESSAGE(WM_SHOW_LATLONG,								OnShowLatLong)
	ON_MESSAGE(WM_LBU_IN_GPSPLOT,							OnLBUInGPSGraph)
	ON_MESSAGE(WM_ZOOM_IN_GPSPLOT,						OnZoomGPSGraph)

	ON_MESSAGE(WM_END_EDIT,						OnEndEditLandMarkPosition) // defined in CMeasGrid

	ON_BN_CLICKED(IDC_CHECK_SHOW_SOURCE,		OnBnClickedCheckShowSource)
	ON_EN_CHANGE(IDC_SRC_LAT_EDIT,				OnEnChangeSrcLatEdit)
	ON_EN_CHANGE(IDC_SRC_LON_EDIT,				OnEnChangeSrcLonEdit)
	ON_BN_CLICKED(IDC_CHECK_CALC_DISTANCE,		OnBnClickedCheckCalcDistance)
	ON_WM_LBUTTONUP()
	ON_BN_CLICKED(IDC_SHOW_COLUMN,							OnBnClickedShowColumn)
	ON_BN_CLICKED(IDC_SHOW_ALTITUDE,						OnBnClickedShowAltitude)
	ON_BN_CLICKED(IDC_SHOW_INTENSITY,						OnBnClickedShowIntensity)
	ON_LBN_SELCHANGE(IDC_EVALLOG_LIST,						OnLbnSelchangeEvallogList)
	ON_BN_CLICKED(IDC_CHECK_SHOW_INTERPOLATED_WINDFIELD,	OnBnClickedCheckShowInterpolatedWindfield)
	ON_BN_CLICKED(IDC_BTN_IMPORT_WINDFIELD,					OnBnClickedBtnImportWindfield)
	ON_NOTIFY(UDN_DELTAPOS, IDC_ROUTEDLG_POINTSIZESPIN,		OnDeltaposRoutedlgPointsizespin)
	ON_EN_CHANGE(IDC_ROUTDLG_POINTSIZEEDIT,					OnEnChangeRoutdlgPointsizeedit)

	// Changing the colors
	ON_COMMAND(ID_COLORS_BACKGROUND,				OnChangeBackgroundColor)
	ON_COMMAND(ID_CHANGECOLORS_GRID,				OnChangeGridColor)
	ON_COMMAND(ID_CHANGECOLORS_WINDFIELD,			OnChangeWindFieldColor)
	ON_COMMAND(ID_CHANGECOLORS_CIRCLES,				OnChangeCirclesColor)

	// Setting the color-scale
	ON_COMMAND(ID_CHANGECOLORS_COLORSCALEBW,			OnChangeColorScale_BW)
	ON_COMMAND(ID_CHANGECOLORS_COLORSCALEDEFAULT,	OnChangeColorScale_Default)

	// Changing the look of the grid
	ON_COMMAND(ID_GRID_INCREASE,							OnGridIncrease)
	ON_COMMAND(ID_GRID_DECREASE,							OnGridDecrease)

	// Showing or not showing the scale of the plot
	ON_COMMAND(ID_SHOWHIDESCALE,							OnChangeShowScale)

	// Saving the route-graph
	ON_COMMAND(ID_FILE_SAVEGRAPHASIMAGE,			OnFileSaveGraphAsImage)

	// How the column-values should be shown, as different colors or as different point-sizes
	ON_COMMAND(ID_INDICATECOLUMNVALUEBY_COLOR,									OnMenuViewShowColumnByColor)
	ON_COMMAND(ID_INDICATECOLUMNVALUEBY_SIZEOFCIRCLE,						OnMenuViewShowColumnBySize)
	ON_UPDATE_COMMAND_UI(ID_INDICATECOLUMNVALUEBY_COLOR,				OnUpdateMenuShowColumnByColor)
	ON_UPDATE_COMMAND_UI(ID_INDICATECOLUMNVALUEBY_SIZEOFCIRCLE,	OnUpdateMenuShowColumnBySize)

	// Showing or hiding the source
	ON_BN_CLICKED(IDC_BTN_SOURCE_LAT, OnBnClickedSourceLat)
	ON_BN_CLICKED(IDC_BTN_SOURCE_LON, OnBnClickedSourceLon)

	// Updating the interface, notice that this has to be here due to a bug in Microsoft MFC
	//	http://support.microsoft.com/kb/242577
	ON_WM_INITMENUPOPUP()

	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CRouteDlg message handlers


BOOL CRouteDlg::OnInitDialog() {
	CString str, errorMessage;

	CDialog::OnInitDialog();

	CRect rect;
	rect = CRect(20,20,700,700);
	m_gpsPlot.Create(WS_VISIBLE | WS_CHILD, rect, this) ; 
	memcpy(&m_gpsPlot.rect, &rect, sizeof(CRect));
	m_gpsPlot.parentWnd = this;
//	m_gpsPlot.SetBackgroundColor(RGB(0, 0, 0)) ;
//	m_gpsPlot.SetGridColor(RGB(255,255,255));
	m_gpsPlot.EnableGridLinesX(true);
	m_gpsPlot.SetMarginSpace(0.05f);

	// Initialize the list of landmarks
	m_frameLandmarks.GetWindowRect(&rect);
	int width = rect.right - rect.left;
	int height = rect.bottom - rect.top;

	rect.top = 20;
	rect.left = 10;
	rect.right = width - 20;
	rect.bottom = height - 10;

	m_gridLandMarks.Create(rect, &m_frameLandmarks, 0);
	m_gridLandMarks.parent = this;
	while(m_gridLandMarks.GetColumnCount() > 0)
		m_gridLandMarks.DeleteColumn(0);
	m_gridLandMarks.InsertColumn("Lat (dd.dd)");
	m_gridLandMarks.InsertColumn("Long (dd.dd)");
	m_gridLandMarks.SetFixedRowCount(1);
	m_gridLandMarks.SetFixedColumnCount(0);
	for(int i = 0; i < 2; ++i)
		m_gridLandMarks.SetColumnWidth(i, (int) (rect.right/2.5));

	m_gridLandMarks.SetEditable(TRUE); /* make sure the user can edit the positions */
	m_gridLandMarks.SetRowCount(10);

	// customize the control
	this->m_showSourceCheck.SetCheck(m_showSource);

	m_showInterpolatedWindField.SetCheck(0);

	this->SetDlgItemText(IDC_BEARING_LABEL, "");  
	this->SetDlgItemText(IDC_DISTANCE_LABEL, "");  

	this->m_selectedDisplay = SHOW_COLUMN;

	str.Format("%d", m_pointSize);
	m_pointSizeEdit.SetWindowText(str);
	m_pointSizeSpin.SetBuddy(&m_pointSizeEdit);

	// check so that there are not too many traveses...
	if(m_flux->m_traverseNum >= MAX_FLUX_LOGFILES){
		errorMessage.Format("Maximum number of traverses that can be plotted simultaneously is %d. Will only show the first %d measurements.", MAX_FLUX_LOGFILES, MAX_FLUX_LOGFILES);
		MessageBox(errorMessage);
		m_traversesToShow = MAX_FLUX_LOGFILES;
	}else{
		m_traversesToShow = m_flux->m_traverseNum;
	}
	
	/* the list of evaluation logs */
	for(int i = 0; i < m_traversesToShow; ++i){
		this->m_evalLogList.AddString(m_flux->m_traverse[i]->m_fileName);
	}
	m_evalLogList.SetSel(m_initalSelection, TRUE);

	InitBuffers();

	SetWidthOfLogList();

	DrawRouteGraph();

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

void CRouteDlg::DrawRouteGraph(){
	double marginSpace;
	struct plotRange range;
	CString scaleStr, tmpStr;
	static double u[MAX_TRAVERSELENGTH], v[MAX_TRAVERSELENGTH];
	int i;

	GetPlotRange(range);

	/* Set the width of the margins around the plot */
	marginSpace = 1e-2 + 5e-2 * std::max(range.maxLon - range.minLon, range.maxLat - range.minLat);

	/* Fix the settings of the plot */
	m_gpsPlot.SetYUnits("Latitude");
	m_gpsPlot.SetXUnits("Longitude");
	m_gpsPlot.SetAxisEqual();
	m_gpsPlot.SetMarginSpace(marginSpace);
	m_gpsPlot.SetRange(range.minLon, range.maxLon, 3, range.minLat, range.maxLat, 3);

	/* draw the traverse */
	for(i = 0; i < m_traversesToShow; ++i){
		if(!m_evalLogList.GetSel(i))
		continue;

		/** Draw the wind field, if wanted */
		if(m_showInterpolatedWindField.GetCheck() && m_useWindField[i]){
		Common common;
			
		m_gpsPlot.SetPlotColor(m_windFieldColor);

		double avgWind = Average(m_ws[i], m_recordLen[i]);
		double scaling = 0.05 * (range.maxLat - range.minLat) / avgWind;

		for(int k = 0; k < m_recordLen[i]; ++k){
			u[k] = scaling * m_ws[i][k] * sin(DEGREETORAD * m_wd[i][k]);
			v[k] = scaling * m_ws[i][k] * cos(DEGREETORAD * m_wd[i][k]);
		}
		m_gpsPlot.DrawVectorField(m_lon[i], m_lat[i], u, v, m_recordLen[i]);
		}

		m_gpsPlot.SetCircleRadius(m_pointSize);
		m_gpsPlot.SetCircleColor(m_circlesColor);

		// The options for the plot
		int plotOption = Graph::CGraphCtrl::PLOT_FIXED_AXIS;
		if(m_showColumnOption == 1)
			plotOption |= Graph::CGraphCtrl::PLOT_SCALE_CIRCLE;

		switch(m_selectedDisplay){
			case SHOW_INTENSITY:
				m_gpsPlot.DrawCircles(m_lon[i], m_lat[i], m_int[i], m_recordLen[i], plotOption);
				break;
			case SHOW_ALTITUDE:
				m_gpsPlot.DrawCircles(m_lon[i], m_lat[i], m_alt[i], m_recordLen[i], plotOption);
				break;
			case SHOW_COLUMN:
				m_gpsPlot.DrawCircles(m_lon[i], m_lat[i], m_col[i], m_recordLen[i], plotOption);
				break;
			default:
				m_gpsPlot.DrawCircles(m_lon[i], m_lat[i], m_col[i], m_recordLen[i], plotOption);
		}

		/* draw the start of the traverse*/
		m_gpsPlot.SetCircleColor(RGB(0, 255, 0));
		m_gpsPlot.SetCircleRadius(6);
		m_gpsPlot.DrawCircles(m_lon[i], m_lat[i], 1, Graph::CGraphCtrl::PLOT_FIXED_AXIS);
		m_gpsPlot.SetPlotColor(RGB(255, 255, 255), false);
	}

	/* draw the source */
	if(1 == m_showSourceCheck.GetCheck()){
		m_gpsPlot.SetCircleColor(RGB(255, 0, 0));
		m_gpsPlot.SetCircleRadius(7);
		m_gpsPlot.DrawCircles(&m_srcLon, &m_srcLat, 1, Graph::CGraphCtrl::PLOT_FIXED_AXIS);
		m_gpsPlot.SetPlotColor(RGB(255, 255, 255), false);
	}

	/* Draw the landmarks */
	for(i = 0; i < m_gridLandMarks.GetRowCount() - 1; ++i){
		double lat, lon;
		tmpStr = m_gridLandMarks.GetCell(i + 1, 0)->GetText();
		if(0 >= sscanf(tmpStr, "%lf", &lat))
			continue;

		tmpStr = m_gridLandMarks.GetCell(i + 1, 1)->GetText();
		if(0 >= sscanf(tmpStr, "%lf", &lon))
			continue;

		m_gpsPlot.SetCircleColor(RGB(0, 0, 255));
		m_gpsPlot.DrawCircles(&lon, &lat, 1, Graph::CGraphCtrl::PLOT_FIXED_AXIS);
	}

	/* Draw the scale of the plot */
	if(1 == m_showScale){
		double	sLat[2], sLong[2]; // the latitudes and longitudes for the 'scale'
		double plotwidth			= 1e-3 * GPSDistance(m_gpsPlot.GetYMin(), m_gpsPlot.GetXMin(), m_gpsPlot.GetYMin(), m_gpsPlot.GetXMax());
		double scaleWidth			= 1e3 * round(plotwidth / 4); // the length of the scale
		sLat[0]								= sLat[1] = m_gpsPlot.GetYMin() + 0.1 * (m_gpsPlot.GetYMax() - m_gpsPlot.GetYMin());
		sLong[0]							=	m_gpsPlot.GetXMin() + 0.1 * (m_gpsPlot.GetXMax() - m_gpsPlot.GetXMin());
		CalculateDestination(sLat[0], sLong[0], scaleWidth, 90, sLat[1], sLong[1]);
		// draw the distance line...
		m_gpsPlot.SetPlotColor(m_gpsPlot.GetGridColor());
		m_gpsPlot.DrawVector(sLong[0], sLat[0], sLong[1]-sLong[0], sLat[1]-sLat[0], false);

		// Print the number...
		scaleStr.Format("%.0lf km", scaleWidth * 1e-3);
		m_gpsPlot.DrawTextBox(sLong[0], sLong[1], sLat[0], sLat[0] + 0.03*(m_gpsPlot.GetYMax() - m_gpsPlot.GetYMin()), scaleStr);
	}

}

LRESULT CRouteDlg::OnShowLatLong(WPARAM wParam, LPARAM lParam){
	CString tmpStrLat, tmpStrLon;

	tmpStrLat.Format("Lat: %lf", m_gpsPlot.curLat);
	tmpStrLon.Format("Long: %lf", m_gpsPlot.curLong);

	this->SetDlgItemText(IDC_STATIC_LATITUDE, tmpStrLat);
	this->SetDlgItemText(IDC_STATIC_LONGITUDE, tmpStrLon);

	UpdateData(FALSE); 
	return 0;
}

void CRouteDlg::OnBnClickedCheckShowSource()
{
	// TODO: Add your control notification handler code here
	char txt[256];

	GetDlgItemText(IDC_SRC_LAT_EDIT, txt, 256);
	sscanf(txt, "%lf", &m_srcLat);

	GetDlgItemText(IDC_SRC_LON_EDIT, txt, 256);
	sscanf(txt, "%lf", &m_srcLon);

	m_showSource = m_showSourceCheck.GetCheck();

	DrawRouteGraph();

}
void CRouteDlg::OnEnChangeSrcLatEdit()
{
	char txt[256];
	this->GetDlgItemText(IDC_SRC_LAT_EDIT, txt, 256);
	if(strlen(txt) != 0){ 
		UpdateData(TRUE);
		if(1 == m_showSourceCheck.GetCheck())
		DrawRouteGraph();
	}
}

void CRouteDlg::OnEnChangeSrcLonEdit()
{
	char txt[256];
	this->GetDlgItemText(IDC_SRC_LON_EDIT, txt, 256);
	if(strlen(txt) != 0){
		UpdateData(TRUE);
		if(1 == m_showSourceCheck.GetCheck())
		DrawRouteGraph();
	}
}

void CRouteDlg::OnBnClickedCheckCalcDistance(){
	if(1 == m_calcDistance.GetCheck()){
		/* start calculating distance */
		this->SetDlgItemText(IDC_DISTANCE_LABEL, "Click on position 1");
		this->SetDlgItemText(IDC_BEARING_LABEL, "");
	}else{
		/* clear the distance calculations */

	}
	nClicks = 0;
	lat1 = lat2 = lon1 = lon2 = 0;
}

LRESULT CRouteDlg::OnLBUInGPSGraph(WPARAM wParam, LPARAM lParam){
	CString tmpStr1, tmpStr2;
	double bearing, distance;

	if(1 == m_calcDistance.GetCheck()){
		/* If we should calculate distance */

		if(nClicks == 0){
		lat1 = m_gpsPlot.curLat;
		lon1 = m_gpsPlot.curLong;
		this->SetDlgItemText(IDC_DISTANCE_LABEL, "Click on position 2");
		this->SetDlgItemText(IDC_BEARING_LABEL, "");
		}

		if(nClicks == 1){
		lat2 = m_gpsPlot.curLat;
		lon2 = m_gpsPlot.curLong;

		bearing = GPSBearing(lat1, lon1, lat2, lon2);
		distance = GPSDistance(lat1, lon1, lat2, lon2);
		if(distance < 1000)
			tmpStr1.Format("Dist.: %.0lf [m]", distance);
		else
			tmpStr1.Format("Dist.: %.2lf [km]", distance/1000);

		tmpStr2.Format("Bearing: %.3lf [deg]", bearing);
	      
		this->SetDlgItemText(IDC_BEARING_LABEL, tmpStr2);  
		this->SetDlgItemText(IDC_DISTANCE_LABEL, tmpStr1);  
		nClicks = -1;
		}

		++nClicks;
	}

	return 0;
}

LRESULT CRouteDlg::OnZoomGPSGraph(WPARAM wparam, LPARAM lparam){

	// Redraw the graph
	DrawRouteGraph();


	return 0;
}

void CRouteDlg::OnBnClickedShowColumn(){
	UpdateData(TRUE);
	DrawRouteGraph();
}

void CRouteDlg::OnBnClickedShowAltitude(){
	UpdateData(TRUE);
	DrawRouteGraph();
}

void CRouteDlg::OnBnClickedShowIntensity(){
	UpdateData(TRUE);
	DrawRouteGraph();
}

void CRouteDlg::GetPlotRange(struct plotRange &range){
	CString tmpStr;
	double latRange, lonRange;
	Common common;
	int i;
	struct plotRange rect;

	// See if the user has determined any range...
	m_gpsPlot.GetZoomRect(rect);
	if(fabs(rect.maxLat) > 0.1){
		range = rect;
		return;
	}

	range.maxLat = range.maxLon = -1e10;
	range.minLat = range.minLon = -1e10;
	for(i = 0; i < m_traversesToShow; ++i){
		if(!m_evalLogList.GetSel(i))
		continue;

		if(range.maxLat < -180){
		range.maxLat = m_lat[i][0];
		range.minLat = m_lat[i][0];
		range.maxLon = m_lon[i][0];
		range.minLon = m_lon[i][0];
		}

		if(m_flux->hasValidGPS()){
		range.maxLat = std::max(Max(m_lat[i], m_recordLen[i]), range.maxLat);
		range.maxLon = std::max(Max(m_lon[i], m_recordLen[i]), range.maxLon);
		range.minLat = std::min(Min(m_lat[i], m_recordLen[i]), range.minLat);
		range.minLon = std::min(Min(m_lon[i], m_recordLen[i]), range.minLon);
		}
	}

	if(1 == this->m_showSourceCheck.GetCheck()){
		/* show the source */

		if(range.maxLat < -180){
		range.maxLat = m_srcLat;
		range.minLat = m_srcLat;
		range.maxLon = m_srcLon;
		range.minLon = m_srcLon;
		}
		range.minLat = std::min(range.minLat, m_srcLat);
		range.maxLat = std::max(range.maxLat, m_srcLat);
		range.minLon = std::min(range.minLon, m_srcLon);
		range.maxLon = std::max(range.maxLon, m_srcLon);
	}else{
		if(range.maxLat < -180){
		range.maxLat = 1;
		range.minLat = -1;
		range.maxLon = 1;
		range.minLon = -1;
		}
	}

	// The landmarks...
	for(i = 0; i < m_gridLandMarks.GetRowCount() - 1; ++i){
		double lat, lon;
		tmpStr = m_gridLandMarks.GetCell(i + 1, 0)->GetText();
		if(0 >= sscanf(tmpStr, "%lf", &lat))
			continue;

		tmpStr = m_gridLandMarks.GetCell(i + 1, 1)->GetText();
		if(0 >= sscanf(tmpStr, "%lf", &lon))
			continue;

		range.minLat = std::min(range.minLat, lat);
		range.maxLat = std::max(range.maxLat, lat);
		range.minLon = std::min(range.minLon, lon);
		range.maxLon = std::max(range.maxLon, lon);
	}

	/* make sure that the plot is square */
	latRange = range.maxLat - range.minLat;
	lonRange = range.maxLon - range.minLon;
	if(latRange > lonRange){
		double half = (range.maxLon + range.minLon) / 2;
		range.minLon = half - latRange/2;
		range.maxLon = half + latRange/2;
	}else{
		double half = (range.maxLat + range.minLat) / 2;
		range.minLat = half - lonRange/2;
		range.maxLat = half + lonRange/2;
	}

	return;
}

void CRouteDlg::GetColorRange(double &minValue, double &maxValue){
	int i;
	Common common;

	minValue = 0;
	maxValue = 1;

	for(i = 0; i < m_traversesToShow; ++i){
		if(!m_evalLogList.GetSel(i))
		continue;

		switch(m_selectedDisplay){
		case SHOW_INTENSITY:
			minValue = std::min(Min(m_int[i], m_recordLen[i]), minValue);
			maxValue = std::max(Max(m_int[i], m_recordLen[i]), maxValue);
			break;
		case SHOW_ALTITUDE:
			minValue = std::min(Min(m_alt[i], m_recordLen[i]), minValue);
			maxValue = std::max(Max(m_alt[i], m_recordLen[i]), maxValue);
			break;
		case SHOW_COLUMN:
			minValue = std::min(Min(m_col[i], m_recordLen[i]), minValue);
			maxValue = std::max(Max(m_col[i], m_recordLen[i]), maxValue);
			break;
		default:
			minValue = std::min(Min(m_col[i], m_recordLen[i]), minValue);
			maxValue = std::max(Max(m_col[i], m_recordLen[i]), maxValue);
		}
	}
}

void CRouteDlg::InitBuffers(){
	int i, j, k, sum;

	for(i = 0; i < m_traversesToShow; ++i){
		Flux::CTraverse *tr = m_flux->m_traverse.GetAt(i);
		memcpy(m_lon[i], tr->longitude, tr->m_recordNum*sizeof(double));
		memcpy(m_lat[i], tr->latitude, tr->m_recordNum*sizeof(double));
		memcpy(m_alt[i], tr->altitude, tr->m_recordNum*sizeof(double));
		memcpy(m_col[i], tr->columnArray, tr->m_recordNum*sizeof(double));
		memcpy(m_int[i], tr->intensArray, tr->m_recordNum*sizeof(double));
		memcpy(m_ws[i],  tr->m_windSpeed, tr->m_recordNum*sizeof(double));
		memcpy(m_wd[i],  tr->m_windDirection, tr->m_recordNum*sizeof(double));

		m_useWindField[i] = tr->m_useWindField;

		/* delete bad points */
		sum = tr->m_recordNum;
		for(j = 0; j < sum; ++j){
			if(m_lat[i][j] == 0 && m_lon[i][j] == 0){
				for(k = j; k < sum; ++k){
					m_lat[i][k] = m_lat[i][k + 1];
					m_lon[i][k] = m_lon[i][k + 1];
					m_ws[i][k]  = m_ws[i][k + 1];
					m_wd[i][k]  = m_wd[i][k + 1];
				}
				--j;
				--sum;
			}
		}
		m_recordLen[i] = sum;
	}
}

void CRouteDlg::OnLbnSelchangeEvallogList(){
	DrawRouteGraph();
}


void CRouteDlg::OnBnClickedCheckShowInterpolatedWindfield(){
	DrawRouteGraph();
}

void CRouteDlg::OnBnClickedBtnImportWindfield()
{
	int nSelected = 0, curSel = -1;
	for(int i = 0; i < m_traversesToShow; ++i){
		if(!m_evalLogList.GetSel(i))
		continue;
		++nSelected;
		curSel = i;
	}
	if(nSelected > 1){
		MessageBox("Can only import windfield for one traverse. Please select only one traverse and try again", "Error", MB_OK);
		return;
	}
	if(nSelected == 0){
		MessageBox("Please select one traverse and try again", "Error", MB_OK);
		return;
	}

	// import windfield
	CWindFieldDlg dlg;
	dlg.m_flux = m_flux;

	INT_PTR ok = dlg.DoModal();

	// update the route dialog
	this->m_useWindField[curSel] = true;
	this->InitBuffers();
}

// Called when the user has pressed the spin button that controlls the
//  radius of the circles which make up the traverse
void CRouteDlg::OnDeltaposRoutedlgPointsizespin(NMHDR *pNMHDR, LRESULT *pResult)
{
	CString str;
	LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);

	// Check which direction the user has pressed the spinbutton (which is upside down)
	//  and change the circle radius accordingly
	if(pNMUpDown->iDelta > 0)
		--m_pointSize;
	if(pNMUpDown->iDelta < 0)
		++m_pointSize;
	  
	// Enforce the limits
	m_pointSize = std::max(1, m_pointSize);

	// Update the screen
	str.Format("%d", m_pointSize);
	m_pointSizeEdit.SetWindowText(str);

	*pResult = 0;
}

// Called when the number in the 'point size' edit has changed
void CRouteDlg::OnEnChangeRoutdlgPointsizeedit()
{
	DrawRouteGraph();
}

void CRouteDlg::OnChangeBackgroundColor()
{
	CColorDialog dlg;
	COLORREF bkColor;

	if(dlg.DoModal() == IDOK){
		bkColor = dlg.m_cc.rgbResult;
		m_gpsPlot.SetBackgroundColor(bkColor);
	}
	DrawRouteGraph();
}

void CRouteDlg::OnChangeGridColor()
{
	CColorDialog dlg;
	COLORREF gColor;

	if(dlg.DoModal() == IDOK){
		gColor = dlg.m_cc.rgbResult;
		m_gpsPlot.SetGridColor(gColor);
	}
	DrawRouteGraph();
}

void CRouteDlg::OnChangeWindFieldColor()
{
	CColorDialog dlg;

	if(dlg.DoModal() == IDOK){
		m_windFieldColor = dlg.m_cc.rgbResult;
	}
	DrawRouteGraph();
}

void CRouteDlg::OnChangeCirclesColor()
{
	CColorDialog dlg;

	if(dlg.DoModal() == IDOK){
		m_circlesColor = dlg.m_cc.rgbResult;
	}
	DrawRouteGraph();
}

void CRouteDlg::OnChangeColorScale_BW(){
	m_circlesColor		= RGB(0, 0, 0);
	m_windFieldColor	= RGB(10, 10, 10);

	m_gpsPlot.SetGridColor(RGB(0, 0, 0));
	m_gpsPlot.SetBackgroundColor(RGB(255, 255, 255));

	DrawRouteGraph();
}
void CRouteDlg::OnChangeColorScale_Default(){
	m_circlesColor		= RGB(0, 255, 0);
	m_windFieldColor	= RGB(255, 255, 255);

	m_gpsPlot.SetGridColor(RGB(255, 255, 255));
	m_gpsPlot.SetBackgroundColor(RGB(0, 0, 0));

	DrawRouteGraph();
}


void CRouteDlg::OnGridIncrease()
{
	//m_gpsPlot.IncreaseGridDensity();
	DrawRouteGraph();
}

void CRouteDlg::OnGridDecrease()
{
//  m_gpsPlot.DecreaseGridDensity();
	DrawRouteGraph();
}

void CRouteDlg::OnFileSaveGraphAsImage(){
	CString fileName;

	// Get the fileName
	if(Common::BrowseForFile_SaveAs("*.png;*.bmp;*.gif;*.jpg", fileName)){
		if(!Equals(fileName.Right(4), ".png") && !Equals(fileName.Right(4), ".bmp")  && !Equals(fileName.Right(4), ".gif")  && !Equals(fileName.Right(4), ".jpg"))
			fileName.AppendFormat(".png");

		m_gpsPlot.SaveGraph(fileName);
	}
}

void CRouteDlg::SetWidthOfLogList(){

	// Find the longest string in the list box.
	CString      str;
	CSize      sz;
	int					dx = 0;
	TEXTMETRIC   tm;
	CDC*					pDC = m_evalLogList.GetDC();
	CFont*      pFont = m_evalLogList.GetFont();

	// Select the listbox font, save the old font
	CFont* pOldFont = pDC->SelectObject(pFont);
	// Get the text metrics for avg char width
	pDC->GetTextMetrics(&tm); 

	for (int i = 0; i < m_evalLogList.GetCount(); i++)
	{
				m_evalLogList.GetText(i, str);
		sz = pDC->GetTextExtent(str);

		// Add the avg width to prevent clipping
		sz.cx += tm.tmAveCharWidth;

		if (sz.cx > dx)
							dx = sz.cx;
	}
	// Select the old font back into the DC
	pDC->SelectObject(pOldFont);
	m_evalLogList.ReleaseDC(pDC);

	// Set the horizontal extent so every character of all strings 
	// can be scrolled to.
	m_evalLogList.SetHorizontalExtent(dx);
}

/** Turns on or off the showing of the scale */
void CRouteDlg::OnChangeShowScale(){

	// change the current status of the showing of the scale
	m_showScale = !m_showScale;


	DrawRouteGraph();
}

LRESULT CRouteDlg::OnEndEditLandMarkPosition(WPARAM wParam, LPARAM lParam){
	DrawRouteGraph();

	return 0;
}
void CRouteDlg::OnBnClickedSourceLat()
{
	Dialogs::CSourceSelectionDlg sourceDlg;
	INT_PTR modal = sourceDlg.DoModal();
	if(IDOK == modal){
		m_srcLat = sourceDlg.m_selectedLat;
		m_srcLon = sourceDlg.m_selectedLon;

		m_showSourceCheck.SetCheck(1);

		UpdateData(FALSE);

		DrawRouteGraph();
	}

	UpdateData(FALSE);
}

void CRouteDlg::OnBnClickedSourceLon()
{
	OnBnClickedSourceLat();
}


void CRouteDlg::OnMenuViewShowColumnByColor(){
	m_showColumnOption = 0;
	DrawRouteGraph(); // <-- update the graph
}
void CRouteDlg::OnMenuViewShowColumnBySize(){
	m_showColumnOption = 1;
	DrawRouteGraph(); // <-- update the graph
}
void CRouteDlg::OnUpdateMenuShowColumnByColor(CCmdUI *pCmdUI){
	// set the check status of this item to the same as the check status of the 'intensity' check box
	if(m_showColumnOption == 0){
		pCmdUI->SetCheck(1);
	}else{
		pCmdUI->SetCheck(0);
	}
}
void CRouteDlg::OnUpdateMenuShowColumnBySize(CCmdUI *pCmdUI){
	// set the check status of this item to the same as the check status of the 'intensity' check box
	if(m_showColumnOption == 1){
		pCmdUI->SetCheck(1);
	}else{
		pCmdUI->SetCheck(0);
	}
}

void CRouteDlg::OnInitMenuPopup(CMenu *pPopupMenu, UINT nIndex,BOOL bSysMenu)
{
	ASSERT(pPopupMenu != nullptr);
	// Check the enabled state of various menu items.

	CCmdUI state;
	state.m_pMenu = pPopupMenu;
	ASSERT(state.m_pOther == nullptr);
	ASSERT(state.m_pParentMenu == nullptr);

	// Determine if menu is popup in top-level menu and set m_pOther to
	// it if so (m_pParentMenu == NULL indicates that it is secondary popup).
	HMENU hParentMenu;
	if (AfxGetThreadState()->m_hTrackingMenu == pPopupMenu->m_hMenu)
		state.m_pParentMenu = pPopupMenu;    // Parent == child for tracking popup.
	else if ((hParentMenu = ::GetMenu(m_hWnd)) != nullptr)
	{
		CWnd* pParent = this;
		// Child windows don't have menus--need to go to the top!
		if (pParent != nullptr &&
			(hParentMenu = ::GetMenu(pParent->m_hWnd)) != nullptr)
		{
			int nIndexMax = ::GetMenuItemCount(hParentMenu);
			for (int nIndex = 0; nIndex < nIndexMax; nIndex++)
			{
				if (::GetSubMenu(hParentMenu, nIndex) == pPopupMenu->m_hMenu)
				{
					// When popup is found, m_pParentMenu is containing menu.
					state.m_pParentMenu = CMenu::FromHandle(hParentMenu);
					break;
				}
			}
		}
	}

	state.m_nIndexMax = pPopupMenu->GetMenuItemCount();
	for (state.m_nIndex = 0; state.m_nIndex < state.m_nIndexMax;
	state.m_nIndex++)
	{
		state.m_nID = pPopupMenu->GetMenuItemID(state.m_nIndex);
		if (state.m_nID == 0)
		continue; // Menu separator or invalid cmd - ignore it.

		ASSERT(state.m_pOther == nullptr);
		ASSERT(state.m_pMenu != nullptr);
		if (state.m_nID == (UINT)-1)
		{
		// Possibly a popup menu, route to first item of that popup.
		state.m_pSubMenu = pPopupMenu->GetSubMenu(state.m_nIndex);
		if (state.m_pSubMenu == nullptr ||
			(state.m_nID = state.m_pSubMenu->GetMenuItemID(0)) == 0 ||
			state.m_nID == (UINT)-1)
		{
			continue;       // First item of popup can't be routed to.
		}
			state.DoUpdate(this, TRUE);   // Popups are never auto disabled.
		}
		else
		{
			// Normal menu item.
			// Auto enable/disable if frame window has m_bAutoMenuEnable
			// set and command is _not_ a system command.
			state.m_pSubMenu = nullptr;
			state.DoUpdate(this, FALSE);
		}

		// Adjust for menu deletions and additions.
		UINT nCount = pPopupMenu->GetMenuItemCount();
		if (nCount < state.m_nIndexMax)
		{
			state.m_nIndex -= (state.m_nIndexMax - nCount);
			while (state.m_nIndex < nCount && pPopupMenu->GetMenuItemID(state.m_nIndex) == state.m_nID){
				state.m_nIndex++;
			}
		}
		state.m_nIndexMax = nCount;
	}
}