Samuele E. Locatelli
958 lines
30 KiB
C#
958 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Windows.Forms;
|
|
using Flir.Atlas.Image;
|
|
using Flir.Atlas.Live.Device;
|
|
using Flir.Atlas.Live.Discovery;
|
|
using Newtonsoft.Json;
|
|
using ThermoCamUtils;
|
|
|
|
namespace ThermalImageStreamerDemo
|
|
{
|
|
public partial class MainForm : Form
|
|
{
|
|
#region Private Fields
|
|
|
|
private const string FileFilter = "IR Image Files(*.jpg;*.img;*.seq;*.fcf)|*.jpg;*.img;*.seq;*.fcf|All files (*.*)|*.*";
|
|
|
|
private readonly Timer _timerRefreshUi = new Timer();
|
|
|
|
#if false
|
|
private Camera IRCam.ThermoCamera;
|
|
#endif
|
|
|
|
private RecorderForm _recorder;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Protected Fields
|
|
|
|
protected const string colorPath = "images\\Color";
|
|
|
|
protected const string confFileName = "ThermoConf.json";
|
|
|
|
protected const string currImgFile = "ThermalData.jpg";
|
|
|
|
protected const string thermPath = "images\\Therm";
|
|
|
|
/// <summary>
|
|
/// Ultimo range di temperature osservato
|
|
/// </summary>
|
|
protected Range<double> _lastTempRange = new Range<double>(-999, 5000);
|
|
|
|
protected int currPoint = -1;
|
|
|
|
/// <summary>
|
|
/// Contenitore oggetti Image x FlirCam
|
|
/// </summary>
|
|
protected ImageData ImgData = new ImageData();
|
|
|
|
#if false
|
|
protected double lastCalcTemp = 0;
|
|
|
|
protected Point ImgData.lastPoint = new Point();
|
|
|
|
protected double lastReadTemp = 0;
|
|
#endif
|
|
|
|
protected double msLastCam = 0;
|
|
|
|
protected double msLastCol = 0;
|
|
|
|
protected double msLastMsr = 0;
|
|
|
|
protected double msLastPts = 0;
|
|
|
|
protected double msLastTra = 0;
|
|
|
|
protected Point refTempPoint = new Point();
|
|
|
|
protected Stopwatch sw = new Stopwatch();
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Public Fields
|
|
|
|
// Config File Names
|
|
public static readonly string BASE_PATH = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public MainForm()
|
|
{
|
|
InitializeComponent();
|
|
_timerRefreshUi.Interval = 100;
|
|
_timerRefreshUi.Tick += _timerRefreshUi_Tick;
|
|
// cerco se ho un set di parametri già impostati...
|
|
tryReloadConf();
|
|
// calcolo i currConf.destPoints
|
|
updateDestPt();
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Private Properties
|
|
|
|
private bool IsDirty { get; set; }
|
|
|
|
private bool liveView
|
|
{
|
|
get
|
|
{
|
|
return checkLive.Checked;
|
|
}
|
|
set
|
|
{
|
|
checkLive.Checked = value;
|
|
}
|
|
}
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Protected Properties
|
|
|
|
protected string confPath
|
|
{
|
|
get
|
|
{
|
|
// se esiste il file... path assoluto
|
|
string answ = confFileName;
|
|
if (!Path.IsPathRooted(answ))
|
|
{
|
|
answ = BASE_PATH + "\\" + confFileName;
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
protected ThermoCamConf currConf
|
|
{
|
|
get
|
|
{
|
|
return ImgData.currConf;
|
|
}
|
|
set
|
|
{
|
|
ImgData.currConf = value;
|
|
}
|
|
}
|
|
|
|
protected int dimX
|
|
{
|
|
get
|
|
{
|
|
int answ = 100;
|
|
int.TryParse(txtAB.Text, out answ);
|
|
currConf.TargetSize.X = answ;
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
currConf.TargetSize.X = value;
|
|
txtAB.Text = $"{value}";
|
|
}
|
|
}
|
|
|
|
protected int dimY
|
|
{
|
|
get
|
|
{
|
|
int answ = 100;
|
|
int.TryParse(txtBC.Text, out answ);
|
|
currConf.TargetSize.Y = answ;
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
currConf.TargetSize.Y = value;
|
|
txtBC.Text = $"{value}";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ultimo range di temperature osservato
|
|
/// </summary>
|
|
protected Range<double> lastTempRange
|
|
{
|
|
get
|
|
{
|
|
return _lastTempRange;
|
|
}
|
|
set
|
|
{
|
|
_lastTempRange = value;
|
|
lblMinTemp.Text = $"{value.Minimum:N2}";
|
|
lblMaxTemp.Text = $"{value.Maximum:N2}";
|
|
}
|
|
}
|
|
|
|
protected double maxScale
|
|
{
|
|
get
|
|
{
|
|
double answ = 1000;
|
|
double.TryParse(txtMaxScale.Text, out answ);
|
|
currConf.TargetRange.Max = answ;
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
currConf.TargetRange.Max = value;
|
|
txtMaxScale.Text = $"{value:N0}";
|
|
}
|
|
}
|
|
|
|
protected double minScale
|
|
{
|
|
get
|
|
{
|
|
double answ = 0;
|
|
double.TryParse(txtMinScale.Text, out answ);
|
|
currConf.TargetRange.Min = answ;
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
currConf.TargetRange.Min = value;
|
|
txtMinScale.Text = $"{value:N0}";
|
|
}
|
|
}
|
|
|
|
protected bool pointSetup
|
|
{
|
|
get
|
|
{
|
|
return chkPointSetup.Checked;
|
|
}
|
|
set
|
|
{
|
|
chkPointSetup.Checked = value;
|
|
}
|
|
}
|
|
|
|
protected bool readTemp
|
|
{
|
|
get
|
|
{
|
|
return chkReadTemp.Checked;
|
|
}
|
|
set
|
|
{
|
|
chkReadTemp.Checked = value;
|
|
}
|
|
}
|
|
|
|
protected bool saveEnabled
|
|
{
|
|
get
|
|
{
|
|
return chkSaveAll.Checked;
|
|
}
|
|
set
|
|
{
|
|
chkSaveAll.Checked = value;
|
|
}
|
|
}
|
|
|
|
protected bool showOrigBig
|
|
{
|
|
get
|
|
{
|
|
return chkShowOrig.Checked;
|
|
}
|
|
set
|
|
{
|
|
chkShowOrig.Checked = value;
|
|
}
|
|
}
|
|
|
|
#endregion Protected Properties
|
|
|
|
#region Private Methods
|
|
|
|
private void _recorder_SelectedFileMouseDoubleClick(object sender, SelectedFileEventArgs e)
|
|
{
|
|
var playback = new PlaybackForm(e.FilePath);
|
|
playback.Show();
|
|
}
|
|
|
|
private void _timerRefreshUi_Tick(object sender, EventArgs e)
|
|
{
|
|
// se è in live view --> continuo
|
|
if (liveView)
|
|
{
|
|
takePicture(saveEnabled);
|
|
processImage();
|
|
refreshDisplay();
|
|
}
|
|
// avanzo prog bar
|
|
progBar.Increment(3);
|
|
if (progBar.Value >= progBar.Maximum)
|
|
{
|
|
progBar.Value = 0;
|
|
}
|
|
}
|
|
|
|
private void btnLoad_Click(object sender, EventArgs e)
|
|
{
|
|
string dirPath = $"{BASE_PATH}\\{thermPath}";
|
|
string filePath = $"{dirPath}\\{currImgFile}";
|
|
if (File.Exists(filePath))
|
|
{
|
|
try
|
|
{
|
|
ImgData.Thermal = new ThermalImageFile(filePath);
|
|
ImgData.Thermal.TemperatureUnit = TemperatureUnit.Celsius;
|
|
ImgData.Thermal.Scale.IsAutoAdjustEnabled = true;
|
|
// carico DIRETTAMENTE da file...
|
|
ImgData.Origin = (Bitmap)Image.FromFile(filePath);
|
|
ImgData.Decorated = (Bitmap)Image.FromFile(filePath);
|
|
|
|
// aggiorno visualizzazione
|
|
processImage();
|
|
refreshDisplay();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
}
|
|
|
|
private void btnReset_Click(object sender, EventArgs e)
|
|
{
|
|
pointSetup = true;
|
|
currConf.origPoints = new SetPoints();
|
|
}
|
|
|
|
private void btnSave_Click(object sender, EventArgs e)
|
|
{
|
|
takePicture(true);
|
|
processImage();
|
|
refreshDisplay();
|
|
}
|
|
|
|
private void Camera_ConnectionStatusChanged(object sender, Flir.Atlas.Live.ConnectionStatusChangedEventArgs e)
|
|
{
|
|
BeginInvoke((Action)(() => toolStripConnectionStatus.Text = e.Status.ToString()));
|
|
BeginInvoke((Action)(() => cameraToolStripMenuItem.Enabled = e.Status == ConnectionStatus.Connected));
|
|
// se si disconnette --> NUOVA richiesta connessione alla CHILD...
|
|
|
|
// TODO FARE!!!
|
|
}
|
|
|
|
private void checkLive_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
// non serve fare nulla
|
|
}
|
|
|
|
private void chkPointSetup_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
// deselezione Get Temp
|
|
if (readTemp)
|
|
{
|
|
readTemp = false;
|
|
}
|
|
}
|
|
|
|
private void chkReadTemp_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
// deselezione setup punti
|
|
if (pointSetup)
|
|
{
|
|
pointSetup = false;
|
|
}
|
|
if (!readTemp)
|
|
{
|
|
lblReadTemp.Text = "? °C";
|
|
lblTempRGB.Text = "? °C";
|
|
}
|
|
}
|
|
|
|
private void ConnectCamera(CameraDeviceInfo cameraDeviceInfo)
|
|
{
|
|
DisposeCamera();
|
|
switch (cameraDeviceInfo.SelectedStreamingFormat)
|
|
{
|
|
case ImageFormat.FlirFileFormat:
|
|
IRCam.ThermoCamera = new ThermalCamera();
|
|
break;
|
|
|
|
case ImageFormat.Argb:
|
|
IRCam.ThermoCamera = new VideoOverlayCamera();
|
|
break;
|
|
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
IRCam.ThermoCamera.ConnectionStatusChanged += Camera_ConnectionStatusChanged;
|
|
IRCam.ThermoCamera.GetImage().Changed += Image_Changed;
|
|
IRCam.ThermoCamera.Connect(cameraDeviceInfo);
|
|
if (IRCam.ThermoCamera.Recorder == null && _recorder != null)
|
|
{
|
|
_recorder.Dispose();
|
|
_recorder = null;
|
|
}
|
|
if (_recorder != null)
|
|
{
|
|
if (!_recorder.IsDisposed)
|
|
_recorder.Initialize(IRCam.ThermoCamera);
|
|
}
|
|
recorderToolStripMenuItem.Enabled = IRCam.ThermoCamera.Recorder != null;
|
|
_timerRefreshUi.Start();
|
|
}
|
|
|
|
private void DisconnectCamera()
|
|
{
|
|
if (IRCam.ThermoCamera == null) return;
|
|
|
|
IRCam.ThermoCamera.Disconnect();
|
|
}
|
|
|
|
private void disconnectToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
DisconnectCamera();
|
|
}
|
|
|
|
private void discoveryToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
var discoveryDlg = new DiscoveryForm();
|
|
if (discoveryDlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
ConnectCamera(discoveryDlg.SelectedCameraDevice);
|
|
// salvo nome camera in conf attuale!
|
|
currConf.CameraName = discoveryDlg.SelectedCameraDevice.Name;
|
|
saveConf();
|
|
}
|
|
}
|
|
|
|
private void displayImages()
|
|
{
|
|
if (ImgData.Thermal != null)
|
|
{
|
|
lblImgA.Text = showOrigBig ? "ORIGINAL image" : "FINAL image";
|
|
lblImgB.Text = showOrigBig ? "FINAL image" : "ORIGINAL image";
|
|
|
|
pBoxA.Image = showOrigBig ? ImgData.ColorTransf : ImgData.Decorated;
|
|
pBoxB.Image = showOrigBig ? ImgData.Decorated : ImgData.ColorTransf;
|
|
pBoxC.Image = ImgData.GrayTransf;
|
|
}
|
|
}
|
|
|
|
private void DisposeCamera()
|
|
{
|
|
_timerRefreshUi.Stop();
|
|
if (IRCam.ThermoCamera == null) return;
|
|
if (_recorder != null)
|
|
{
|
|
_recorder.UnInitialize();
|
|
_recorder.Dispose();
|
|
}
|
|
IRCam.ThermoCamera.ConnectionStatusChanged -= Camera_ConnectionStatusChanged;
|
|
IRCam.ThermoCamera.GetImage().Changed -= Image_Changed;
|
|
IRCam.ThermoCamera.Dispose();
|
|
}
|
|
|
|
private void drawCrossAtPoints()
|
|
{
|
|
if (ImgData.Thermal != null)
|
|
{
|
|
sw.Restart();
|
|
// se ho dei punti x trasformazione --> disegno
|
|
if (currConf.origPoints.curr > 0)
|
|
{
|
|
foreach (var item in currConf.origPoints.Coords)
|
|
{
|
|
drawPoint(Color.Green, item);
|
|
}
|
|
}
|
|
// se ho punto acquisizione temp --> disegno!
|
|
if (refTempPoint != null)
|
|
{
|
|
drawPoint(Color.Blue, refTempPoint);
|
|
}
|
|
sw.Stop();
|
|
msLastPts = sw.ElapsedMilliseconds;
|
|
}
|
|
}
|
|
|
|
private void drawPoint(Color currColor, Point currPoint)
|
|
{
|
|
// disegno!
|
|
using (Graphics gr = Graphics.FromImage(ImgData.Decorated))
|
|
{
|
|
gr.SmoothingMode = SmoothingMode.AntiAlias;
|
|
|
|
Point[] crsPoints = new Point[4];
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
crsPoints[i] = currPoint;
|
|
}
|
|
crsPoints[0].X = crsPoints[0].X - 4;
|
|
crsPoints[1].X = crsPoints[1].X + 4;
|
|
crsPoints[2].Y = crsPoints[2].Y - 4;
|
|
crsPoints[3].Y = crsPoints[3].Y + 4;
|
|
|
|
using (Pen thick_pen = new Pen(currColor, 1))
|
|
{
|
|
gr.DrawLine(thick_pen, crsPoints[0], crsPoints[1]);
|
|
gr.DrawLine(thick_pen, crsPoints[2], crsPoints[3]);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if false
|
|
private void getTemperatures()
|
|
{
|
|
if (ImgData.Thermal != null)
|
|
{
|
|
lastReadTemp = 0;
|
|
if (readTemp)
|
|
{
|
|
// recupero temp da FLIR
|
|
lastReadTemp = ImgData.Thermal.GetValueAt(ImgData.lastPoint).Value;
|
|
|
|
// calcolo temp da RGB considerato limiti minMAX...
|
|
//int rgbVal = ImgData.lastImageOrig.Image.GetPixel(ImgData.lastPoint.X, ImgData.lastPoint.Y).R;
|
|
int rgbVal = getRSmooth(ImgData.lastPoint);
|
|
lastCalcTemp = lastTempRange.Minimum + ((lastTempRange.Maximum - lastTempRange.Minimum) * rgbVal / 255);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
private void Image_Changed(object sender, Flir.Atlas.Image.ImageChangedEventArgs e)
|
|
{
|
|
IsDirty = true;
|
|
}
|
|
|
|
private void lblOrigA_Click(object sender, EventArgs e)
|
|
{
|
|
lblOrigA.ForeColor = toggleEditPoint(0);
|
|
}
|
|
|
|
private void lblOrigB_Click(object sender, EventArgs e)
|
|
{
|
|
lblOrigB.ForeColor = toggleEditPoint(1);
|
|
}
|
|
|
|
private void lblOrigC_Click(object sender, EventArgs e)
|
|
{
|
|
lblOrigC.ForeColor = toggleEditPoint(2);
|
|
}
|
|
|
|
private void lblOrigD_Click(object sender, EventArgs e)
|
|
{
|
|
lblOrigD.ForeColor = toggleEditPoint(3);
|
|
}
|
|
|
|
private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
if (_recorder != null && _recorder.IsDisposed == false)
|
|
{
|
|
_recorder.Dispose();
|
|
}
|
|
|
|
DisposeCamera();
|
|
}
|
|
|
|
private void MainForm_Load(object sender, EventArgs e)
|
|
{
|
|
}
|
|
|
|
private void MainForm_Shown(object sender, EventArgs e)
|
|
{
|
|
// avvio l'autoconnessione
|
|
if (!string.IsNullOrEmpty(currConf.CameraName))
|
|
{
|
|
discoveryCamera();
|
|
}
|
|
}
|
|
|
|
private void openToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
using (var dialog = new OpenFileDialog())
|
|
{
|
|
dialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures) + @"\FLIR";
|
|
dialog.Filter = FileFilter;
|
|
if (dialog.ShowDialog() != DialogResult.OK) return;
|
|
var playback = new PlaybackForm(dialog.FileName);
|
|
playback.Show();
|
|
}
|
|
}
|
|
|
|
private void pictureBox1_Click(object sender, EventArgs e)
|
|
{
|
|
// calcolo la ratio img originale --> pictureBox
|
|
double ratio = 1;
|
|
try
|
|
{
|
|
if (ImgData.Origin != null && ImgData.Origin.Width > 0)
|
|
{
|
|
ratio = (double)pBoxA.Width / ImgData.Origin.Width;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
// trasformo punto in equivalente originale
|
|
var mea = (MouseEventArgs)e;
|
|
ImgData.lastPoint = new Point() { X = (int)(mea.X / ratio), Y = (int)(mea.Y / ratio) };
|
|
lblPoint.Text = $"({mea.X},{mea.Y}) --> ({ImgData.lastPoint.X},{ImgData.lastPoint.Y})";
|
|
if (pointSetup)
|
|
{
|
|
// max 4 punti... se sono già FULL --> imposto singolo valore nuovo
|
|
if (currConf.origPoints.curr >= 4)
|
|
{
|
|
if (currPoint >= 0)
|
|
{
|
|
currConf.origPoints.Coords[currPoint] = ImgData.lastPoint;
|
|
}
|
|
else
|
|
{
|
|
currConf.origPoints = new SetPoints();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// salvo coordinate in base al num corrente...
|
|
try
|
|
{
|
|
currConf.origPoints.Coords.Add(ImgData.lastPoint);
|
|
currConf.origPoints.curr++;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
// salvo conf
|
|
saveConf();
|
|
|
|
// aggiorno visualizzazione
|
|
processImage();
|
|
refreshDisplay();
|
|
}
|
|
else if (readTemp)
|
|
{
|
|
refTempPoint = ImgData.lastPoint;
|
|
// aggiorno visualizzazione
|
|
processImage();
|
|
refreshDisplay();
|
|
}
|
|
}
|
|
|
|
private void processImage()
|
|
{
|
|
// disegno immagine
|
|
ImgData.getTemperatures(readTemp);
|
|
ImgData.calculateTarget(chkParallel.Checked, chkRevProc.Checked);
|
|
}
|
|
|
|
private void recorderToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
if (_recorder == null || _recorder.IsDisposed)
|
|
{
|
|
_recorder = new RecorderForm();
|
|
_recorder.Initialize(IRCam.ThermoCamera);
|
|
_recorder.SelectedFileMouseDoubleClick += _recorder_SelectedFileMouseDoubleClick;
|
|
}
|
|
_recorder.Show();
|
|
_recorder.Focus();
|
|
}
|
|
|
|
private void refreshDisplay()
|
|
{
|
|
drawCrossAtPoints();
|
|
displayImages();
|
|
updateDisplay();
|
|
updateTempDisplay();
|
|
updateStatDisplay();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva su file il file di conf corrente
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private bool saveConf()
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
string rawData = JsonConvert.SerializeObject(currConf, Formatting.Indented);
|
|
File.WriteAllText(confPath, rawData);
|
|
answ = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
private void saveImgFile()
|
|
{
|
|
try
|
|
{
|
|
// fix percorsi
|
|
string dirPath = $"{BASE_PATH}\\{thermPath}";
|
|
string filePath = $"{dirPath}\\{currImgFile}";
|
|
if (!Directory.Exists(dirPath))
|
|
{
|
|
Directory.CreateDirectory(dirPath);
|
|
}
|
|
// salvo!
|
|
ImgData.Thermal.Scale.IsAutoAdjustEnabled = true;
|
|
ImgData.Thermal.SaveSnapshot(filePath);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupera immagine effettuando eventuale salvataggio
|
|
/// </summary>
|
|
/// <param name="doSave"></param>
|
|
private void takePicture(bool doSave)
|
|
{
|
|
sw.Restart();
|
|
if (!IsDirty) return;
|
|
IsDirty = false;
|
|
if (IRCam.ThermoCamera == null) return;
|
|
|
|
IRCam.ThermoCamera.GetImage().EnterLock();
|
|
try
|
|
{
|
|
// non funziona
|
|
#if false
|
|
// se richiesto imposto temperature min/max...
|
|
if (!chkAutoTemp.Checked)
|
|
{
|
|
Range<double> limits = new Range<double>(273.1 + minTemp, 273.1 + maxTemp);
|
|
IRCam.ThermoCamera.RemoteControl.CameraSettings.SetScaleLimits(limits);
|
|
}
|
|
#endif
|
|
ImgData.Thermal = (ThermalImage)IRCam.ThermoCamera.GetImage();
|
|
ImgData.Thermal.TemperatureUnit = TemperatureUnit.Celsius;
|
|
ImgData.Thermal.Scale.IsAutoAdjustEnabled = true;
|
|
// salvo img locale
|
|
ImgData.Origin = ImgData.Thermal.Image;
|
|
ImgData.Decorated = ImgData.Thermal.Image;
|
|
if (doSave)
|
|
{
|
|
saveImgFile();
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Trace.TraceError(exception.Message);
|
|
}
|
|
finally
|
|
{
|
|
IRCam.ThermoCamera.GetImage().ExitLock();
|
|
}
|
|
|
|
sw.Stop();
|
|
msLastCam = sw.ElapsedMilliseconds;
|
|
|
|
#if false
|
|
ThermalImage myImg = (ThermalImage)_stream.GetImage();
|
|
myImg.TemperatureUnit = TemperatureUnit.Celsius;
|
|
string currPath = $"{labelOutputPath.Text}\\{DateTime.Now:yyyyMMyy_HHmmss}.jpg";
|
|
myImg.SaveSnapshot(currPath);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se il punto era in edit, altrimenti segnala e lo attiva... restituendo colore x il controllo
|
|
/// </summary>
|
|
/// <param name="selPoint"></param>
|
|
private Color toggleEditPoint(int selPoint)
|
|
{
|
|
Color answ = Color.Black;
|
|
lblOrigA.ForeColor = answ;
|
|
lblOrigB.ForeColor = answ;
|
|
lblOrigC.ForeColor = answ;
|
|
lblOrigD.ForeColor = answ;
|
|
readTemp = false;
|
|
pointSetup = true;
|
|
if (currPoint == selPoint)
|
|
{
|
|
// deseleziono
|
|
currPoint = -1;
|
|
}
|
|
else
|
|
{
|
|
// indico selezionato
|
|
currPoint = selPoint;
|
|
answ = Color.Green;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
private void tryReloadConf()
|
|
{
|
|
if (File.Exists(confPath))
|
|
{
|
|
// se non è vuoto....
|
|
string rawData = File.ReadAllText(confPath);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
try
|
|
{
|
|
currConf = JsonConvert.DeserializeObject<ThermoCamConf>(rawData);
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
}
|
|
}
|
|
}
|
|
|
|
private void txtAB_TextChanged(object sender, EventArgs e)
|
|
{
|
|
// ricalcolo in proporzione altro valore...
|
|
dimY = (int)((double)dimX * 256 / 320);
|
|
// aggiorno punti dest
|
|
updateDestPt();
|
|
}
|
|
|
|
private void txtBC_TextChanged(object sender, EventArgs e)
|
|
{
|
|
// ricalcolo in proporzione altro valore...
|
|
dimX = (int)((double)dimY * 320 / 256);
|
|
// aggiorno punti dest
|
|
updateDestPt();
|
|
}
|
|
|
|
private void updateDestPt()
|
|
{
|
|
currConf.destPoints.Coords = new List<Point>();
|
|
// ciclo i punti A-B-C-D...
|
|
currConf.destPoints.Coords.Add(new Point() { X = 0, Y = 0 });
|
|
currConf.destPoints.Coords.Add(new Point() { X = dimX, Y = 0 });
|
|
currConf.destPoints.Coords.Add(new Point() { X = dimX, Y = dimY });
|
|
currConf.destPoints.Coords.Add(new Point() { X = 0, Y = dimY });
|
|
// salvo conf
|
|
saveConf();
|
|
}
|
|
|
|
private void updateDisplay()
|
|
{
|
|
lblOrigA.Text = "A";
|
|
lblOrigB.Text = "B";
|
|
lblOrigC.Text = "C";
|
|
lblOrigD.Text = "D";
|
|
// popolo
|
|
if (currConf.origPoints.Coords.Count > 0)
|
|
{
|
|
lblOrigA.Text = $"A: ({currConf.origPoints.Coords[0].X},{currConf.origPoints.Coords[0].Y})";
|
|
}
|
|
if (currConf.origPoints.Coords.Count > 1)
|
|
{
|
|
lblOrigB.Text = $"B: ({currConf.origPoints.Coords[1].X},{currConf.origPoints.Coords[1].Y})";
|
|
}
|
|
if (currConf.origPoints.Coords.Count > 2)
|
|
{
|
|
lblOrigC.Text = $"C: ({currConf.origPoints.Coords[2].X},{currConf.origPoints.Coords[2].Y})";
|
|
}
|
|
if (currConf.origPoints.Coords.Count > 3)
|
|
{
|
|
lblOrigD.Text = $"D: ({currConf.origPoints.Coords[3].X},{currConf.origPoints.Coords[3].Y})";
|
|
ImgData.calculateTarget(chkParallel.Checked, chkRevProc.Checked);
|
|
}
|
|
}
|
|
|
|
private void updateStatDisplay()
|
|
{
|
|
lblStats.Text = $"Camera: {msLastCam}ms | Persp {msLastTra}ms | Color {msLastCol}ms | Points {msLastPts}ms | Measures {msLastMsr}ms";
|
|
}
|
|
|
|
private void updateTempDisplay()
|
|
{
|
|
if (ImgData.Thermal != null)
|
|
{
|
|
if (readTemp)
|
|
{
|
|
// mostro temp da FLIR
|
|
lblReadTemp.Text = $"{ImgData.lastReadTemp:N2} °C";
|
|
|
|
//calcolo da immagine B/N
|
|
lblTempRGB.Text = $"{ImgData.lastCalcTemp:N2} °C";
|
|
// cambio colore se > 1 grado...
|
|
double delta = Math.Abs(ImgData.lastReadTemp - ImgData.lastCalcTemp);
|
|
if (delta < 1)
|
|
{
|
|
lblTempRGB.ForeColor = Color.Black;
|
|
}
|
|
else if (delta < 2)
|
|
{
|
|
lblTempRGB.ForeColor = Color.Blue;
|
|
}
|
|
else if (delta < 3)
|
|
{
|
|
lblTempRGB.ForeColor = Color.Orange;
|
|
}
|
|
else
|
|
{
|
|
lblTempRGB.ForeColor = Color.Red;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
|
|
#if false
|
|
/// <summary>
|
|
/// Calcola valore R ponderato dato un punto + intorno
|
|
/// </summary>
|
|
/// <param name="reqPoint"></param>
|
|
/// <returns></returns>
|
|
protected int getRSmooth(Point reqPoint)
|
|
{
|
|
int answ = 0;
|
|
if (ImgData.Origin != null)
|
|
{
|
|
// solo se il punto è entro limiti immagine --> 1 pixel entro bordo
|
|
if (reqPoint.X > 0 && reqPoint.X < ImgData.Origin.Width)
|
|
{
|
|
if (reqPoint.Y > 0 && reqPoint.Y < ImgData.Origin.Height)
|
|
{
|
|
int rgbValMain = ImgData.Origin.GetPixel(ImgData.lastPoint.X, ImgData.lastPoint.Y).R;
|
|
|
|
int rgbValN = ImgData.Origin.GetPixel(ImgData.lastPoint.X, ImgData.lastPoint.Y - 1).R;
|
|
int rgbValNO = ImgData.Origin.GetPixel(ImgData.lastPoint.X - 1, ImgData.lastPoint.Y - 1).R;
|
|
int rgbValO = ImgData.Origin.GetPixel(ImgData.lastPoint.X - 1, ImgData.lastPoint.Y).R;
|
|
int rgbValSO = ImgData.Origin.GetPixel(ImgData.lastPoint.X - 1, ImgData.lastPoint.Y + 1).R;
|
|
int rgbValS = ImgData.Origin.GetPixel(ImgData.lastPoint.X, ImgData.lastPoint.Y + 1).R;
|
|
int rgbValSE = ImgData.Origin.GetPixel(ImgData.lastPoint.X + 1, ImgData.lastPoint.Y + 1).R;
|
|
int rgbValE = ImgData.Origin.GetPixel(ImgData.lastPoint.X + 1, ImgData.lastPoint.Y).R;
|
|
int rgbValNE = ImgData.Origin.GetPixel(ImgData.lastPoint.X + 1, ImgData.lastPoint.Y - 1).R;
|
|
// calcolo valore ponderato
|
|
answ = (int)Math.Round((double)(1 * rgbValMain + 1 * (rgbValN + rgbValO + rgbValS + rgbValE) + rgbValNO + rgbValSO + rgbValSE + rgbValNE) / 10, 0);
|
|
}
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
#endif
|
|
|
|
#region Public Methods
|
|
|
|
public void discoveryCamera()
|
|
{
|
|
var discoveryDialog = new DiscoveryForm();
|
|
discoveryDialog.CameraName = currConf.CameraName;
|
|
if (!string.IsNullOrEmpty(currConf.CameraName))
|
|
{
|
|
//discoveryDialog.WindowState = FormWindowState.Minimized;
|
|
if (discoveryDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
ConnectCamera(discoveryDialog.SelectedCameraDevice);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
} |