private void toolStripButton3_Click(object sender, EventArgs e)
{
if (lstFrames.SelectedItems.Count > 0)
{
List <ILogger> loggers = new List <ILogger>();
loggers.Add(mainForm.ConsoleLogger);
ProgressBarWnd wnd = new ProgressBarWnd();
wnd.Text = "Exporting frame...";
wnd.ProgressBarStyle = ProgressBarStyle.Blocks;
loggers.Add(wnd);
MultipleLogger logger = new MultipleLogger(loggers);
HotFrame hotFrame = lstFrames.SelectedItems[0].Tag as HotFrame;
var rootFolder = project.Folder + "\\" + Project.MetadataFolder;
var annot = hotFrame.Timestamp.ToString("HH_mm_ss");
wnd.Worker.DoWork += delegate(object senderWorker, DoWorkEventArgs eWorker)
{
MatlabExporter.ExportHotFrame(rootFolder, annot, hotFrame, MatlabExporterOptions.Overwrite, logger, wnd.CancelTokenSource.Token);
};
wnd.ShowDialog();
}
}
public void SetFrameByTimeWithoutRender(DateTime time, HotFrame hotFrame)
{
CurrentHotFrame = hotFrame;
time = time.AddSeconds(-18);
try
{
double dt = veloReader.SeekByTime(time, VelodyneReader.SearchType.FLOOR);
if (dt > 1)
{
viewer.Clear();
lblStatus.Text = "Out of bounds!";
return;
}
lblStatus.Text = "Time difference: " + dt.ToString("0.000") + "s";
NextFrame(); // skip partial frame
NextFrame(); // skip partial frame
}
catch (Exception ex)
{
viewer.Clear();
lblStatus.Text = "Error occured while loading data!";
logger?.WriteLineError(ex.Message);
}
}
public void SetHotFrame(HotFrame frame)
{
SetFrameByTime(frame.Timestamp);
CurrentHotFrame = frame;
// update coordinates in the feature
GPSFeature gpsFeature = null;
foreach (var feature in frame.Features)
{
var gpsFeatureCurr = feature as GPSFeature;
if (gpsFeatureCurr != null)
{
if (gpsFeatureCurr.DataStream.Name == this.DataStream.Name)
{
gpsFeature = gpsFeatureCurr;
}
}
}
if (gpsFeature == null)
{
gpsFeature = new GPSFeature(this.DataStream, this.CurrentPosition);
frame.Features.Add(gpsFeature);
}
gpsFeature.Position = this.CurrentPosition;
}
private void playToolStripMenuItem_Click(object sender, EventArgs e)
{
MainForm form = ((MainForm)this.MdiParent);
if (form.TimeLineWnd.CurrentHotFrame == null)
{
MessageBox.Show("Frame is not selected. Frame has to be selected to tie the current video time to the global time. Use frame window to select a frame!", "Cannot tie", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
HotFrame hotFrame = form.TimeLineWnd.CurrentHotFrame;
// depricated
/*DateTime? gtn = form.GlobalTime;
* if (gtn == null)
* {
* logger.WriteLineError("No global time is selected! Open the timeline window and select a time.");
* MessageBox.Show("No global time is selected! Open the timeline window nad select a time.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
* return;
* }*/
DateTime gt = hotFrame.Timestamp;
TimeFeature timeFeautre = new TimeFeature(DataStream, currentDataLine, CurrentTime, hotFrame);
// remove features with the same datastrean
hotFrame.Features.RemoveAll(x => (x is TimeFeature) && (x.DataStream == DataStream));
hotFrame.Features.Add(timeFeautre);
double delay = new TimeSpan(gt.Ticks - CurrentTime.Ticks).TotalSeconds;
dataStream.ApplyDelay(delay, TimeType.ESTIMATED);
SetFrameByTime(gt);
}
private void toolStripButton2_Click(object sender, EventArgs e)
{
if (lstFrames.SelectedItems.Count > 0)
{
HotFrame hotFrame = lstFrames.SelectedItems[0].Tag as HotFrame;
project.HotFrames.Remove(hotFrame);
UpdateUI();
}
}
private void lstFrames_MouseDoubleClick(object sender, MouseEventArgs e)
{
if (lstFrames.SelectedItems.Count > 0)
{
HotFrame hotFrame = lstFrames.SelectedItems[0].Tag as HotFrame;
mainForm.ShowTimeLineWnd();
mainForm.TimeLineWnd.SetHotFrame(hotFrame);
}
}
public void SetHotFrame(HotFrame frame)
{
SetFrameByTime(frame.Timestamp);
CurrentHotFrame = frame;
frameBox.Refresh();
ImageFeature imageFeature = frame.GetImageFeatureByDataStream(dataStream);
imageFeature.Image = frameBox.Image;
imageFeature.TimeStamp = currentDataLine.TimeStamp;
}
private void toolStripButton1_Click(object sender, EventArgs e)
{
DateTime?time = mainForm.GlobalTime;
if (time != null)
{
HotFrame frame = new HotFrame(time.Value);
project.HotFrames.Add(frame);
UpdateUI();
}
else
{
MessageBox.Show("No frame selected! Use the Timeline window to select frame!", "Select frame...", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private void toolStripButton4_Click(object sender, EventArgs e)
{
if (lstFrames.SelectedItems.Count > 0)
{
HotFrame hotFrame = lstFrames.SelectedItems[0].Tag as HotFrame;
if (hotFrame != null)
{
PropertiesWnd wnd = new PropertiesWnd(hotFrame, false);
if (wnd.ShowDialog() == DialogResult.OK)
{
Refresh();
}
}
}
}
/// <summary>
/// Set hotframe for all IStreamWindow
/// </summary>
/// <param name="frame">Hotframe object</param>
public void SetHotFrame(HotFrame frame)
{
foreach (Form form in mainForm.MdiChildren)
{
if ((!form.IsDisposed) && (form is IStreamWindow))
{
IStreamWindow streamForm = form as IStreamWindow;
if (streamForm.HasToSetFrame)
{
streamForm.SetHotFrame(frame);
Form streamFormAsForm = streamForm as Form;
streamFormAsForm.Refresh();
}
}
}
SetTrackBarTime(frame.Timestamp);
CurrentHotFrame = frame;
}
private void lstFrames_Click(object sender, EventArgs e)
{
if (lstFrames.SelectedItems.Count > 0)
{
HotFrame hotFrame = lstFrames.SelectedItems[0].Tag as HotFrame;
String info = "Time: " + hotFrame.Timestamp.ToString("yyyy.MM.dd HH:mm:ss.fff") + Environment.NewLine;
info += "Streams: ";
foreach (Feature feature in hotFrame.Features)
{
info += feature.DataStream.ShortName;
if (feature is TimeFeature)
{
info += "(T)";
}
info += ",";
}
lblInfo.Text = info;
}
}
private void timer_Tick(object sender, EventArgs e)
{
NextFrame();
// Recording mode
if (tsbRecord.Text == recordButtonTextStop)
{
Bitmap snapshot = TakeSnapshot();
try
{
videoWriter.WriteVideoFrame(snapshot);
snapshot.Dispose();
}
catch
{
//...
}
}
// Exporting video
if (tsbExportVideo.Text == saveButtonTextStop)
{
HotFrame frame = new HotFrame(this.CurrentTime);
foreach (Form form in mainForm.MdiChildren)
{
if ((!form.IsDisposed) && (form is IStreamWindow))
{
IStreamWindow streamWnd = form as IStreamWindow;
streamWnd.SetHotFrame(frame);
}
}
var annot = frame.Timestamp.ToString("HH_mm_ss_fff");
MatlabExporter.ExportHotFrame(exportFolder, annot, frame, MatlabExporterOptions.Overwrite, mainForm.ConsoleLogger);
}
}
public void SetHotFrame(HotFrame frame)
{
CurrentHotFrame = frame;
SetFrameByTimeWithoutRender(frame.Timestamp, frame);
viewer.Render();
}
public void SetFrameByTime(DateTime time, HotFrame hotFrame)
{
SetFrameByTimeWithoutRender(time, hotFrame);
viewer.Render();
}
public static void ExportHotFrame(String rootFolder, String annotationName, HotFrame frame,
MatlabExporterOptions options = MatlabExporterOptions.Overwrite, ILogger logger = null, CancellationToken cancelletionToken = default(CancellationToken))
{
// delete features
/*List<Feature> newFeatureSet = new List<Feature>();
* foreach (Feature feature in frame.Features)
* {
* if (feature.DataStream != null) newFeatureSet.Add(feature);
* }
* frame.Features = newFeatureSet;*/
String folderName = rootFolder + "\\frame_" + annotationName;
String matFilePath = folderName + "\\frame_" + annotationName + ".mat";
Directory.CreateDirectory(folderName);
logger?.WriteLineInfo("");
logger?.WriteLineInfo("Convert frame to Matlab MAT format and export images!");
logger?.WriteLineInfo("Export folder: " + folderName);
logger?.WriteLineInfo("MAT file location: " + matFilePath);
List <MLArray> mlList = new List <MLArray>();
Dictionary <DataStream, List <VeloFeature> > velodyneData = new Dictionary <DataStream, List <VeloFeature> >();
if ((options == MatlabExporterOptions.Append) && (File.Exists(matFilePath)))
{
MatFileReader matReader = new MatFileReader(matFilePath);
mlList = matReader.Data;
}
int i = 0;
foreach (Feature feature in frame.Features)
{
logger?.WriteLineInfo("Exporting: " + feature.DataStream.ShortName);
MLStructure structFeatures = new MLStructure(feature.DataStream.ShortName, new int[] { 1, 1 });
structFeatures["Name", 0] = new MLChar(null, feature.DataStream.Name);
structFeatures["ShortName", 0] = new MLChar(null, feature.DataStream.ShortName);
if (cancelletionToken.IsCancellationRequested == true)
{
logger?.WriteLineWarning("Export cancelled!");
return;
}
if (feature is GPSFeature)
{
var gpsFeature = feature as GPSFeature;
structFeatures["Lat", 0] = new MLDouble("", new double[] { gpsFeature.Position.Lat }, 1);
structFeatures["Lon", 0] = new MLDouble("", new double[] { gpsFeature.Position.Lon }, 1);
structFeatures["Height", 0] = new MLDouble("", new double[] { gpsFeature.Position.Height }, 1);
structFeatures["Quality", 0] = new MLDouble("", new double[] { gpsFeature.Position.Quality }, 1);
mlList.Add(structFeatures);
}
else if (feature is ImageFeature)
{
ImageFeature imageFeature = feature as ImageFeature;
structFeatures["Timestamp", 0] = new MLDouble("", new double[] { Utils.ConvertToUnixTimestamp(imageFeature.TimeStamp) }, 1);
structFeatures["TimestampC", 0] = ConvertDateTimeToMLDouble(imageFeature.TimeStamp);
double[][] points = new double[imageFeature.Points.Count][];
int k = 0;
foreach (ImagePoint pt in ((ImageFeature)feature).Points)
{
points[k] = new double[3];
points[k][0] = pt.ID;
points[k][1] = pt.X;
points[k][2] = pt.Y;
k++;
}
if (k != 0)
{
MLDouble arrayPoints = new MLDouble("Points", points);
structFeatures["Points", 0] = arrayPoints;
}
// save images
if (imageFeature.Image != null)
{
using (Bitmap img = new Bitmap(imageFeature.Image))
{
img.Save(folderName + "\\frame_" + annotationName + "_" + feature.DataStream.ShortName + ".bmp");
}
// you can export the images here, but it's very slow and the code also needs to be tested!
/*using (Bitmap img = new Bitmap(imageFeature.Image))
* {
*
* int[] dims = new int[] { img.Width, img.Height, 3 };
* MLDouble arrImg = new MLDouble("Image", dims);
* for (int i = 0; i < img.Width; i++)
* {
* for (int j = 0; j < img.Height; j++)
* {
* Color col = img.GetPixel(i, j);
* arrImg.Set(col.R, i, j + img.Height * 0);
* arrImg.Set(col.G, i, j + img.Height * 1);
* arrImg.Set(col.B, i, j + img.Height * 2);
* }
* }
*
* structFeatures["Image", 0] = arrImg;
* }*/
}
mlList.Add(structFeatures);
}
else if (feature is VeloFeature)
{
VeloFeature veloFeature = feature as VeloFeature;
// if key does not exist create one
if (!velodyneData.ContainsKey(veloFeature.DataStream))
{
velodyneData.Add(veloFeature.DataStream, new List <VeloFeature>());
}
velodyneData[veloFeature.DataStream].Add(veloFeature);
}
i++;
logger?.WriteProgress((double)i / (double)frame.Features.Count() * 100.0);
}
// ok, now finalize velodyne data
foreach (KeyValuePair <DataStream, List <VeloFeature> > entry in velodyneData)
{
if (cancelletionToken.IsCancellationRequested == true)
{
logger?.WriteLineWarning("Export cancelled!");
return;
}
MLStructure structFeatures = new MLStructure(entry.Key.ShortName, new int[] { 1, 1 });
structFeatures["Name", 0] = new MLChar(null, entry.Key.Name);
structFeatures["ShortName", 0] = new MLChar(null, entry.Key.ShortName);
structFeatures["TimeStamp", 0] = new MLDouble("", new double[] { Utils.ConvertToUnixTimestamp(frame.Timestamp) }, 1);
// get number of points
long n_points = 0;
foreach (VeloFeature feature in entry.Value)
{
n_points += feature.Points.Count();
}
if (n_points == 0)
{
logger?.WriteLineWarning(entry.Key.ShortName + ": No features!");
continue;
}
// populate points
double[][] points = new double[n_points][];
int k = 0;
foreach (VeloFeature feature in entry.Value)
{
foreach (VelodynePoint pt in feature.Points)
{
points[k] = new double[9];
points[k][0] = feature.ID;
points[k][1] = pt.X;
points[k][2] = pt.Y;
points[k][3] = pt.Z;
points[k][4] = Convert.ToDouble(pt.Intensity);
points[k][5] = pt.Distance;
points[k][6] = pt.Hz;
points[k][7] = pt.Vz;
points[k][8] = pt.InternalTime;
k++;
}
}
MLDouble arrayPoints = new MLDouble("Points", points);
structFeatures["Points", 0] = arrayPoints;
mlList.Add(structFeatures);
}
try
{
logger?.WriteLineInfo("Saving mat file...");
MatFileWriter mfw = new MatFileWriter(matFilePath, mlList, true);
}
catch (Exception ex)
{
logger?.WriteLineError("Error occured: " + ex.ToString());
return;
}
logger?.WriteProgress(100.0);
logger?.WriteLineInfo("Done.");
}
