public override void PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
{
if (m_SelectedPoint != null)
{
if (e.KeyCode == Keys.Left)
{
int newPixNo = m_SelectedPoint.PixelNo - 1;
if (newPixNo >= m_MasterSpectra.Points[0].PixelNo)
{
m_SelectedPoint = m_MasterSpectra.Points.Single(x => x.PixelNo == newPixNo);
}
m_SpectroscopyController.SelectPixel(m_SelectedPoint.PixelNo);
m_StateManager.Redraw();
}
else if (e.KeyCode == Keys.Right)
{
int newPixNo = m_SelectedPoint.PixelNo + 1;
if (newPixNo <= m_MasterSpectra.Points[m_MasterSpectra.Points.Count - 1].PixelNo)
{
m_SelectedPoint = m_MasterSpectra.Points.Single(x => x.PixelNo == newPixNo);
}
m_SpectroscopyController.SelectPixel(m_SelectedPoint.PixelNo);
m_StateManager.Redraw();
}
}
}
internal void DisplaySelectedDataPoint(int pixelNo, float wavelength)
{
lblPixelNo.Text = (pixelNo - m_Spectra.ZeroOrderPixelNo).ToString();
if (!float.IsNaN(wavelength) && pixelNo >= m_Spectra.ZeroOrderPixelNo)
{
lblWavelength.Text = wavelength.ToString("0.0 A");
lblWavelengthCaption.Visible = true;
lblWavelength.Visible = true;
}
else
{
lblWavelengthCaption.Visible = false;
lblWavelength.Visible = false;
}
SpectraPoint point = m_Spectra.Points.SingleOrDefault(x => x.PixelNo == pixelNo);
if (point != null)
{
lblPixelValue.Text = point.RawValue.ToString("0.0");
}
gbSelection.Visible = true;
}
public override void MouseClick(object sender, MouseEventArgs e)
{
int x1 = m_StateManager.GetSpectraPixelNoFromMouseCoordinates(e.Location);
m_SelectedPoint = m_MasterSpectra.Points.SingleOrDefault(x => x.PixelNo == x1);
if (m_SelectedPoint != null)
{
m_StateManager.Redraw();
m_SpectroscopyController.SelectPixel(m_SelectedPoint.PixelNo);
}
}
public void ApplyGaussianBlur(float fwhm)
{
if (Math.Abs(fwhm) < 0.0001 || float.IsNaN(fwhm))
{
foreach (SpectraPoint point in m_MasterSpectra.Points)
{
point.ProcessedValue = point.RawValue;
}
m_MasterSpectra.ProcessingInfo.GaussianBlur10Fwhm = null;
}
else
{
float[] kernel = new float[21];
for (int i = 0; i < 10; i++)
{
kernel[10 + i] = kernel[10 - i] = GetGaussianValue(fwhm, i);
}
for (int i = 0; i < m_MasterSpectra.Points.Count; i++)
{
SpectraPoint point = m_MasterSpectra.Points[i];
float sum = 0;
float weight = 0;
for (int j = -10; j <= 10; j++)
{
if (j + i > 0 && j + i < m_MasterSpectra.Points.Count - 1)
{
weight += kernel[j + 10];
sum += kernel[j + 10] * m_MasterSpectra.Points[j + i].RawValue;
}
}
if (weight > 0)
{
point.ProcessedValue = sum / weight;
}
else
{
point.ProcessedValue = point.RawValue;
}
}
m_MasterSpectra.ProcessingInfo.GaussianBlur10Fwhm = (int)Math.Round(fwhm * 10);
}
Redraw();
}
public override void PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
{
if (e.KeyCode == Keys.Left)
{
m_SelectedPoint = m_MasterSpectra.Points.SingleOrDefault(x => x.PixelNo == m_SelectedPoint.PixelNo - 1);
}
else if (e.KeyCode == Keys.Right)
{
m_SelectedPoint = m_MasterSpectra.Points.SingleOrDefault(x => x.PixelNo == m_SelectedPoint.PixelNo + 1);
}
if (m_SelectedPoint != null)
{
m_StateManager.Redraw();
m_SpectroscopyController.SelectPixel(m_SelectedPoint.PixelNo);
}
}
internal void CalibrationPointSelected(float selectedWaveLength, bool attemptCalibration, int polynomialOrder)
{
m_SpectroscopyController.SetMarker(m_SelectedPointPos, selectedWaveLength, attemptCalibration, polynomialOrder);
if (m_SpectroscopyController.IsCalibrated())
{
m_SpectroscopyController.SaveCalibratedConfiguration();
m_StateManager.ChangeState <SpectraViewerStateCalibrated>();
}
else
{
m_MarkedCalibrationPoints.Add(new SpectraPoint(m_SelectedPoint));
m_SelectedPoint = null;
m_StateManager.Redraw();
}
}
public override void MouseClick(object sender, MouseEventArgs e)
{
int x1 = m_StateManager.GetSpectraPixelNoFromMouseCoordinates(e.Location);
m_SelectedPoint = m_MasterSpectra.Points.SingleOrDefault(x => x.PixelNo == x1);
if (m_SelectedPoint != null)
{
m_SelectedPointPos = m_SelectedPoint.PixelNo;
if (Control.ModifierKeys != Keys.Control)
{
// Find the local maximum or minimum
List <SpectraPoint> pointsInArea = m_MasterSpectra.Points.Where(x => x.PixelNo >= m_SelectedPoint.PixelNo - SEARCH_AREA_WING && x.PixelNo <= m_SelectedPoint.PixelNo + SEARCH_AREA_WING).ToList();
float maxValue = float.MinValue;
int maxPixelNo = m_SelectedPoint.PixelNo;
float minValue = float.MaxValue;
int minPixelNo = m_SelectedPoint.PixelNo;
foreach (var spectraPoint in pointsInArea)
{
if (spectraPoint.RawValue > maxValue)
{
maxValue = spectraPoint.RawValue;
maxPixelNo = spectraPoint.PixelNo;
}
if (spectraPoint.RawValue < minValue)
{
minValue = spectraPoint.RawValue;
minPixelNo = spectraPoint.PixelNo;
}
}
// Check if local maximum or minimum
if (minPixelNo != m_SelectedPoint.PixelNo && minPixelNo > m_SelectedPoint.PixelNo - SEARCH_AREA_WING && minPixelNo < m_SelectedPoint.PixelNo + SEARCH_AREA_WING)
{
m_SelectedPoint = m_MasterSpectra.Points.Single(x => x.PixelNo == minPixelNo);
}
else if (maxPixelNo != m_SelectedPoint.PixelNo && maxPixelNo > m_SelectedPoint.PixelNo - SEARCH_AREA_WING && maxPixelNo < m_SelectedPoint.PixelNo + SEARCH_AREA_WING)
{
m_SelectedPoint = m_MasterSpectra.Points.Single(x => x.PixelNo == maxPixelNo);
}
if (Control.ModifierKeys == Keys.Shift)
{
// NOTE: Doing a 2-nd order polynomial fit to find the sub-pixel location of the minima
var cal = new MinimaFinder();
pointsInArea = m_MasterSpectra.Points.Where(x => x.PixelNo >= m_SelectedPoint.PixelNo - SEARCH_AREA_WING && x.PixelNo <= m_SelectedPoint.PixelNo + SEARCH_AREA_WING).ToList();
foreach (SpectraPoint point in pointsInArea)
{
cal.AddDataPoint(point.RawSignal, point.PixelNo);
}
cal.Calibrate();
m_SelectedPointPos = cal.GetMinimaCloseTo(m_SelectedPoint.PixelNo);
if (float.IsNaN(m_SelectedPointPos))
{
m_SelectedPointPos = m_SelectedPoint.PixelNo;
}
}
else
{
m_SelectedPointPos = m_SelectedPoint.PixelNo;
}
}
m_StateManager.Redraw();
m_SpectroscopyController.SelectPixel(m_SelectedPoint.PixelNo);
EnsureEnterWavelengthForm();
}
}
internal void CalibrationPointSelectionCancelled()
{
m_SelectedPoint = null;
m_SpectroscopyController.DeselectPixel();
m_StateManager.Redraw();
}
public void DrawSpectra(PictureBox picSpectra, PictureBox picSpectraGraph, bool drawPixels, TangraConfig.SpectraViewDisplaySettings displaySettings)
{
PointF prevPoint = PointF.Empty;
bool isCalibrated = m_SpectroscopyController.IsCalibrated();
int xAxisOffset = isCalibrated ? X_AXIS_WIDTH : 0;
int yAxisOffset = isCalibrated ? Y_AXIS_WIDTH : 0;
float xCoeff = isCalibrated ? m_XCoeffCalibrated : m_XCoeff;
float yCoeff = isCalibrated ? m_YCoeffCalibrated : m_YCoeff;
int pixelArrWidth = m_MasterSpectra.Pixels.GetLength(0);
int pixelArrHeight = m_MasterSpectra.Pixels.GetLength(1);
float xCoeffPixels = picSpectra.Image.Width * 1f / pixelArrWidth;
float yCoeffPixels = picSpectra.Image.Height * 1f / pixelArrHeight;
using (Graphics g = Graphics.FromImage(picSpectra.Image))
using (Graphics g2 = Graphics.FromImage(picSpectraGraph.Image))
{
g2.Clear(displaySettings.PlotBackgroundColor);
if (m_CurrentState != null)
{
m_CurrentState.PreDraw(g2);
}
if (m_ShowCommonLines && isCalibrated)
{
ShowCommonLines(g2, displaySettings);
}
#region Clear both ends of the stipes spectra
float xStripsBeg = xAxisOffset + xCoeff * (m_MasterSpectra.Points[0].PixelNo - m_XOffset) - 1;
float xStripsEnd = xAxisOffset + xCoeff * (m_MasterSpectra.Points[m_MasterSpectra.Points.Count - 1].PixelNo - m_XOffset) + 1;
if (xStripsBeg > 0)
{
g.FillRectangle(displaySettings.GreyBrushes[0], 0, 0, xStripsBeg, picSpectra.Height);
}
if (xStripsEnd < picSpectra.Width)
{
g.FillRectangle(displaySettings.GreyBrushes[0], xStripsBeg, 0, picSpectra.Width - xStripsBeg, picSpectra.Height);
}
#endregion
RectangleF calibratedGraphArea = new RectangleF(X_AXIS_WIDTH, BORDER_GAP, m_View.Width - X_AXIS_WIDTH - BORDER_GAP, m_View.Height - Y_AXIS_WIDTH - BORDER_GAP);
for (int i = 0; i < m_MasterSpectra.Points.Count; i++)
{
SpectraPoint point = m_MasterSpectra.Points[i];
byte clr = (byte)(Math.Max(0, Math.Min(255, Math.Round(point.ProcessedValue * m_ColorCoeff))));
float x = xAxisOffset + xCoeff * (point.PixelNo - m_XOffset);
if (x >= 0)
{
if (drawPixels)
{
for (int y = 0; y < pixelArrHeight; y++)
{
byte pixClr = (byte)(Math.Max(0, Math.Min(255, Math.Round(m_MasterSpectra.Pixels[i, y] * m_ColorCoeff))));
float xx = xAxisOffset + i * xCoeffPixels;
float yy = y * yCoeffPixels;
g.FillRectangle(displaySettings.GreyBrushes[pixClr], xx, yy, 1, 1);
}
}
else
{
g.FillRectangle(displaySettings.GreyBrushes[clr], x, 0, xCoeff, picSpectra.Height);
}
PointF graphPoint = new PointF(x, picSpectraGraph.Image.Height - BORDER_GAP - (float)Math.Round(point.ProcessedValue * yCoeff) - yAxisOffset);
if (prevPoint != PointF.Empty)
{
if (!isCalibrated || (prevPoint.X > calibratedGraphArea.Left && prevPoint.X < calibratedGraphArea.Right && graphPoint.X > calibratedGraphArea.Left && graphPoint.X < calibratedGraphArea.Right))
{
g2.DrawLine(displaySettings.SpectraPen, prevPoint, graphPoint);
}
}
prevPoint = graphPoint;
}
}
g2.FillRectangle(SystemBrushes.ControlDark, X_AXIS_WIDTH, 0, m_View.Width - X_AXIS_WIDTH - BORDER_GAP + 1, BORDER_GAP);
if (m_CurrentState != null)
{
m_CurrentState.PostDraw(g2);
}
if (isCalibrated)
{
DrawAxis(picSpectraGraph, g2, calibratedGraphArea, displaySettings);
}
g.Save();
g2.Save();
}
picSpectra.Invalidate();
picSpectraGraph.Invalidate();
}
