public void TestIsChanged()
{
FrameDrawing d = new FrameDrawing();
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
d.CameraConfig = new CameraConfig(1);
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
d.Freehand = new Image(5, 5);
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
d.Miniature = new Image(5, 5);
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
d.Pause = new Time(5);
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
d.RegionOfInterest = new Area(23, 23, 23, 23);
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
d.Render = new Time(2);
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
d.Drawables.Add(new Line());
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
d.Drawables = null;
Assert.IsTrue(d.IsChanged);
d.IsChanged = false;
}
void EmitLoadDrawings(FrameDrawing drawing = null)
{
if (LoadDrawingsEvent != null && !disposed)
{
LoadDrawingsEvent(drawing);
}
}
public void ProjectStoreAndRetrieve_DrawingsNotDuplicated()
{
Project project = Utils.CreateProject(true);
//Add a Drawing to one Event
var ev = project.Timeline [0];
FrameDrawing drawing = new FrameDrawing();
drawing.CameraConfig = ev.CamerasConfig[0];
drawing.RegionOfInterest = ev.CamerasConfig [0].RegionOfInterest;
drawing.Render = ev.EventTime;
ev.Drawings.Add(drawing);
//Add Playlist
var playlist = new Playlist();
playlist.Name = "testDrawings";
var playlistElement = new PlaylistPlayElement(ev);
playlistElement.Rate = 3;
playlist.Elements.Add(playlistElement);
project.Playlists.Add(playlist);
//Store the project
storage.Store(project);
//Retrieve the project
var projectRetrieved = storage.Retrieve <Project> (project.ID);
var playlistElementRetrieved = (PlaylistPlayElement)projectRetrieved.Playlists [0].Elements [0];
Assert.AreEqual(1, projectRetrieved.Timeline [0].Drawings.Count());
Assert.AreEqual(1, playlistElementRetrieved.Drawings.Count());
Assert.AreEqual(ev, playlistElementRetrieved.Play);
Assert.AreEqual(playlistElement.CamerasConfig, playlistElementRetrieved.CamerasConfig);
Assert.AreEqual(playlistElement.Rate, playlistElementRetrieved.Rate);
}
protected static Image RenderFrameDrawing(IDrawingToolkit tk, Area area, FrameDrawing fd, Image image)
{
Image img;
ISurface surface;
Log.Debug("Rendering frame drawing with ROI: " + area);
surface = tk.CreateSurface((int)area.Width, (int)area.Height);
using (IContext c = surface.Context) {
tk.Context = c;
tk.TranslateAndScale(new Point(-area.Start.X, -area.Start.Y), new Point(1, 1));
tk.DrawImage(image);
foreach (Drawable d in fd.Drawables)
{
ICanvasSelectableObject obj = CanvasFromDrawableObject(d);
obj.Draw(tk, null);
obj.Dispose();
}
if (fd.Freehand != null)
{
tk.DrawImage(fd.Freehand);
}
}
img = surface.Copy();
surface.Dispose();
return(img);
}
void LoadPlayDrawing(FrameDrawing drawing)
{
Pause();
IgnoreTicks = true;
player.Seek(drawing.Render, true, true);
IgnoreTicks = false;
EmitLoadDrawings(drawing);
}
public PlaylistDrawing(FrameDrawing drawing)
{
Duration = new Time(0);
Drawing = drawing;
CamerasConfig = new RangeObservableCollection <CameraConfig> {
new CameraConfig(0)
};
CamerasLayout = null;
}
public void LoadFrame(Image frame)
{
drawing = new FrameDrawing();
scaleFactor = (double)frame.Width / 500;
blackboard.Background = frame;
blackboard.Drawing = drawing;
savetoprojectbutton.Visible = false;
UpdateLineWidth();
UpdateTextSize();
}
/// <summary>
/// Called periodically to update the current time and check if and has reached
/// its stop time, or drawings must been shonw.
/// </summary>
bool Tick()
{
if (StillImageLoaded)
{
EmitTimeChanged(imageLoadedTS, loadedPlaylistElement.Duration);
if (imageLoadedTS >= loadedPlaylistElement.Duration)
{
Config.EventsBroker.EmitNextPlaylistElement(loadedPlaylist);
}
else
{
imageLoadedTS.MSeconds += TIMEOUT_MS;
}
return(true);
}
else
{
Time currentTime = CurrentTime;
if (SegmentLoaded)
{
EmitTimeChanged(currentTime - loadedSegment.Start,
loadedSegment.Stop - loadedSegment.Start);
if (currentTime > loadedSegment.Stop)
{
/* Check if the segment is now finished and jump to next one */
Pause();
Config.EventsBroker.EmitNextPlaylistElement(loadedPlaylist);
}
else
{
var drawings = EventDrawings;
if (drawings != null)
{
/* Check if the event has drawings to display */
FrameDrawing fd = drawings.FirstOrDefault(f => f.Render > videoTS &&
f.Render <= currentTime &&
f.CameraConfig.Index == CamerasConfig [0].Index);
if (fd != null)
{
LoadPlayDrawing(fd);
}
}
}
}
else
{
EmitTimeChanged(currentTime, streamLength);
}
videoTS = currentTime;
Config.EventsBroker.EmitPlayerTick(currentTime);
return(true);
}
}
void HandleLoadDrawingsEvent(FrameDrawing frameDrawing)
{
if (frameDrawing != null)
{
LoadImage(Player.CurrentFrame, frameDrawing);
}
else
{
DrawingsVisible = false;
}
}
void LoadImage(Image image, FrameDrawing drawing)
{
if (image == null)
{
DrawingsVisible = false;
return;
}
blackboard.Background = image;
blackboard.Drawing = drawing;
DrawingsVisible = true;
blackboarddrawingarea.QueueDraw();
}
public void LoadPlay(TimelineEvent play, Image frame, FrameDrawing drawing,
CameraConfig camConfig, Project project)
{
this.play = play;
this.drawing = drawing;
this.project = project;
this.camConfig = camConfig;
scaleFactor = (double)frame.Width / 500;
blackboard.Background = frame;
savetoprojectbutton.Visible = true;
blackboard.Drawing = drawing;
blackboard.RegionOfInterest = drawing.RegionOfInterest;
}
void HandleDrawFrame(TimelineEvent play, int drawingIndex, CameraConfig camConfig, bool current)
{
Image pixbuf;
FrameDrawing drawing = null;
Time pos;
player.Pause();
if (play == null)
{
play = loadedPlay;
}
if (play != null)
{
if (drawingIndex == -1)
{
drawing = new FrameDrawing {
Render = player.CurrentTime,
CameraConfig = camConfig,
RegionOfInterest = camConfig.RegionOfInterest.Clone(),
};
}
else
{
drawing = play.Drawings [drawingIndex];
}
pos = drawing.Render;
}
else
{
pos = player.CurrentTime;
}
if (framesCapturer != null && !current)
{
// FIXME
Time offset = openedProject.Description.FileSet.First().Offset;
pixbuf = framesCapturer.GetFrame(pos + offset, true, -1, -1);
}
else
{
pixbuf = player.CurrentFrame;
}
if (pixbuf == null)
{
guiToolkit.ErrorMessage(Catalog.GetString("Error capturing video frame"));
}
else
{
guiToolkit.DrawingTool(pixbuf, play, drawing, camConfig, openedProject);
}
}
void OnSavetoprojectbuttonClicked(object sender, System.EventArgs e)
{
drawing.RegionOfInterest = blackboard.RegionOfInterest;
if (!play.Drawings.Contains(drawing))
{
play.Drawings.Add(drawing);
}
drawing.Miniature = blackboard.Save();
drawing.Miniature.ScaleInplace(Constants.MAX_THUMBNAIL_SIZE,
Constants.MAX_THUMBNAIL_SIZE);
play.UpdateMiniature();
drawing = null;
Respond(ResponseType.Accept);
}
//FIXME: We need to move the logic of this method to the ViewModel
async Task SaveToProject()
{
drawing.RegionOfInterest = blackboard.RegionOfInterest;
if (!play.Drawings.Contains(drawing))
{
play.Drawings.Add(drawing);
}
drawing.Miniature = blackboard.Save();
drawing.Miniature.ScaleInplace(Constants.MAX_THUMBNAIL_SIZE,
Constants.MAX_THUMBNAIL_SIZE);
play.Model.UpdateMiniature();
drawing = null;
ViewModel.DrawingSaved();
await App.Current.StateController.MoveBack();
}
public void DeleteSelection_1ElementSelected_ElementDeletedFromCanvasAndModel()
{
var drawing = new FrameDrawing();
var cross = new Cross();
var line = new Line();
drawing.Drawables.Add(cross);
drawing.Drawables.Add(line);
blackboard.Drawing = drawing;
blackboard.UpdateSelection(new Selection(blackboard.Objects [0] as IMovableObject, SelectionPosition.All));
blackboard.DeleteSelection();
Assert.AreEqual(1, blackboard.Objects.Count);
Assert.AreEqual(1, drawing.Drawables.Count);
}
public void TestPlayPause()
{
bool loadSent = false;
bool playing = false;
FrameDrawing drawing = null;
player.PlaybackStateChangedEvent += (o, p) => {
playing = p;
};
player.LoadDrawingsEvent += (f) => {
loadSent = true;
drawing = f;
};
/* Start playing */
player.Play();
Assert.IsTrue(loadSent);
Assert.IsNull(drawing);
playerMock.Verify(p => p.Play(), Times.Once());
Assert.IsTrue(player.Playing);
Assert.IsTrue(playing);
/* Go to pause */
loadSent = false;
player.Pause();
Assert.IsFalse(loadSent);
Assert.IsNull(drawing);
playerMock.Verify(p => p.Pause(), Times.Once());
Assert.IsFalse(player.Playing);
Assert.IsFalse(playing);
/* Check now with a still image loaded */
playerMock.ResetCalls();
player.LoadPlaylistEvent(playlist, plImage);
player.Play();
playerMock.Verify(p => p.Play(), Times.Never());
playerMock.Verify(p => p.Pause(), Times.Once());
Assert.IsTrue(player.Playing);
/* Go to pause */
playerMock.ResetCalls();
player.Pause();
playerMock.Verify(p => p.Play(), Times.Never());
playerMock.Verify(p => p.Pause(), Times.Never());
Assert.IsFalse(player.Playing);
}
//FIXME: We need to move the logic of this method to the ViewModel
async Task SaveToFile()
{
string proposed_filename = String.Format("{0}-{1}.png", App.Current.SoftwareName,
DateTime.Now.ToShortDateString().Replace('/', '-'));
string filename = FileChooserHelper.SaveFile(this,
Catalog.GetString("Save File as..."),
proposed_filename, App.Current.SnapshotsDir,
"PNG Images", new string [] { "*.png" });
if (filename != null)
{
System.IO.Path.ChangeExtension(filename, ".png");
blackboard.Save(filename);
drawing = null;
await App.Current.StateController.MoveBack();
}
}
void OnSavebuttonClicked(object sender, System.EventArgs e)
{
string proposed_filename = String.Format("{0}-{1}.png",
Constants.SOFTWARE_NAME,
DateTime.Now.ToShortDateString().Replace('/', '-'));
string filename = FileChooserHelper.SaveFile(this,
Catalog.GetString("Save File as..."),
proposed_filename, Config.SnapshotsDir,
"PNG Images", new string[] { "*.png" });
if (filename != null)
{
System.IO.Path.ChangeExtension(filename, ".png");
blackboard.Save(filename);
drawing = null;
Respond(ResponseType.Accept);
}
}
void LoadImage(Image image, FrameDrawing drawing)
{
if (image == null)
{
DrawingsVisible = false;
return;
}
blackboard.Background = image;
blackboard.Drawing = drawing;
//FIXME: this should show a warning message here?
if (drawing != null && App.Current.LicenseLimitationsService.CanExecute(
VASFeature.OpenZoom.ToString()))
{
blackboard.RegionOfInterest = drawing.RegionOfInterest;
}
DrawingsVisible = true;
blackboarddrawingarea.QueueDraw();
}
public void LoadPlay(TimelineEventVM play, Image frame, FrameDrawing drawing,
CameraConfig camConfig)
{
this.play = play;
this.drawing = drawing;
this.camConfig = camConfig;
scaleFactor = (double)frame.Width / 500;
blackboard.Background = frame;
savetoprojectbutton.Visible = true;
blackboard.Drawing = drawing;
//FIXME: this needs to show a warning message?
if (App.Current.LicenseLimitationsService.CanExecute(VASFeature.OpenZoom.ToString()))
{
blackboard.RegionOfInterest = drawing.RegionOfInterest;
}
UpdateLineWidth();
UpdateTextSize();
}
string CreateStillImage(MediaFile file, FrameDrawing drawing)
{
Image frame, final_image;
string path = System.IO.Path.GetTempFileName().Replace(@"\", @"\\");
capturer = App.Current.MultimediaToolkit.GetFramesCapturer();
capturer.Open(file.FilePath);
frame = capturer.GetFrame(drawing.Render + file.Offset, true, (int)file.DisplayVideoWidth, (int)file.DisplayVideoHeight);
capturer.Dispose();
if (frame == null)
{
Log.Error(String.Format("Could not get frame for file {0} at pos {1}",
file.FilePath, drawing.Render.ToMSecondsString()));
return(null);
}
final_image = VAS.Drawing.Utils.RenderFrameDrawingToImage(App.Current.DrawingToolkit, frame, drawing);
final_image.Save(path);
return(path);
}
private string CreateStillImage(string filename, FrameDrawing drawing)
{
Image frame, final_image;
string path = System.IO.Path.GetTempFileName().Replace(@"\", @"\\");
capturer = multimediaToolkit.GetFramesCapturer();
capturer.Open(filename);
frame = capturer.GetFrame(drawing.Render, true);
capturer.Dispose();
if (frame == null)
{
Log.Error(String.Format("Could not get frame for file {0} at pos {1}",
filename, drawing.Render.ToMSecondsString()));
return(null);
}
final_image = Drawing.Utils.RenderFrameDrawingToImage(Config.DrawingToolkit, frame, drawing);
final_image.Save(path);
return(path);
}
public void DrawingTool(Image image, TimelineEvent play, FrameDrawing drawing,
CameraConfig camConfig, Project project)
{
DrawingTool dialog = new DrawingTool(mainWindow);
dialog.TransientFor = mainWindow;
Log.Information("Drawing tool");
if (play == null)
{
dialog.LoadFrame(image, project);
}
else
{
dialog.LoadPlay(play, image, drawing, camConfig, project);
}
dialog.Show();
dialog.Run();
dialog.Destroy();
}
public void TestSerialization()
{
FrameDrawing d = new FrameDrawing();
d.Miniature = Utils.LoadImageFromFile();
d.Freehand = Utils.LoadImageFromFile();
d.Drawables = new List <Drawable> {
new Line(), new Rectangle()
};
d.CameraConfig = new CameraConfig(2);
d.Render = new Time(1000);
d.Pause = new Time(2000);
Utils.CheckSerialization(d);
FrameDrawing d2 = Utils.SerializeDeserialize(d);
Assert.AreEqual(d.Render, d2.Render);
Assert.AreEqual(d.Pause, d2.Pause);
Assert.AreEqual(d.CameraConfig, d2.CameraConfig);
Assert.AreEqual(d2.Drawables.Count, d.Drawables.Count);
Assert.IsNotNull(d2.Freehand);
Assert.IsNotNull(d2.Miniature);
}
public void TestEventDrawings()
{
FrameDrawing dr, drSent = null;
player.LoadDrawingsEvent += (frameDrawing) => {
drSent = frameDrawing;
};
dr = new FrameDrawing {
Render = evt.Start + 50,
CameraConfig = new CameraConfig(0),
};
currentTime = evt.Start;
PreparePlayer();
/* Checks drawings are loaded when the clock reaches the render time */
evt.Drawings.Add(dr);
player.LoadEvent(mfs, evt, evt.Start, true);
Assert.IsTrue(player.Playing);
currentTime = dr.Render;
player.Seek(currentTime, true, false);
Assert.IsFalse(player.Playing);
Assert.AreEqual(dr, drSent);
player.Play();
Assert.IsNull(drSent);
/* Check only drawings for the first camera are loaded */
dr.CameraConfig = new CameraConfig(1);
currentTime = evt.Start;
player.LoadEvent(mfs, evt, evt.Start, true);
Assert.IsTrue(player.Playing);
currentTime = dr.Render;
player.Seek(currentTime, true, false);
Assert.IsTrue(player.Playing);
Assert.IsNull(drSent);
}
protected virtual void HandleDrawFrame(DrawFrameEvent drawEvent)
{
FrameDrawing drawing = null;
Time pos;
MediaFileSet fileSet;
videoPlayer.PauseCommand.Execute(true);
if (drawEvent.Play != null &&
drawEvent.Play.Model == null)
{
drawEvent.Play = videoPlayer.LoadedElement as TimelineEventVM;
}
fileSet = drawEvent.Play?.Model?.FileSet;
if (drawEvent.Play?.Model != null)
{
if (drawEvent.DrawingIndex == -1)
{
drawEvent.CamConfig = drawEvent.CamConfig ?? new CameraConfig(0);
drawing = new FrameDrawing {
Render = videoPlayer.Player.CurrentTime,
CameraConfig = drawEvent.CamConfig,
RegionOfInterest = drawEvent.CamConfig.RegionOfInterest.Clone(),
};
}
else
{
drawing = drawEvent.Play.Model.Drawings [drawEvent.DrawingIndex];
drawEvent.CamConfig = drawEvent.CamConfig ?? drawing.CameraConfig;
}
pos = drawing.Render;
}
else
{
pos = videoPlayer.Player.CurrentTime;
}
if (drawEvent.Frame == null)
{
IFramesCapturer framesCapturer;
if (fileSet == null)
{
throw new InvalidOperationException("The event doesn't seems to provide a MediaFileset");
}
framesCapturer = App.Current.MultimediaToolkit.GetFramesCapturer();
MediaFile file = fileSet [drawEvent.CamConfig.Index];
framesCapturer.Open(file.FilePath);
drawEvent.Frame = framesCapturer.GetFrame(pos + file.Offset, true,
(int)file.DisplayVideoWidth, (int)file.DisplayVideoHeight);
framesCapturer.Dispose();
}
if (drawEvent.Frame == null)
{
App.Current.Dialogs.ErrorMessage(Catalog.GetString("Error capturing video frame"));
return;
}
dynamic properties = new ExpandoObject();
properties.project = project?.Model ?? drawEvent.Play?.Model?.Project;
properties.timelineEvent = drawEvent.Play;
properties.frame = drawEvent.Frame;
properties.drawing = drawing;
properties.cameraconfig = drawEvent.CamConfig;
App.Current.StateController.MoveToModal(DrawingToolState.NAME, properties);
}
public static Image RenderFrameDrawingToImage(IDrawingToolkit tk, Image image, FrameDrawing fd)
{
Area area = fd.RegionOfInterest;
if (area == null || area.Empty)
{
area = new Area(0, 0, image.Width, image.Height);
}
return(RenderFrameDrawing(tk, area, fd, image));
}
public static Image RenderFrameDrawing(IDrawingToolkit tk, int width, int height, FrameDrawing fd)
{
return(RenderFrameDrawing(tk, new Area(0, 0, width, height), fd, null));
}
public PlaylistDrawing(FrameDrawing drawing)
{
Drawing = drawing;
}
public PlaylistDrawing(FrameDrawing drawing)
{
Drawing = drawing;
}
