private void ParseDrawings(XmlReader r, PointF scale) { // Note: // We do not do a metadata.AddDrawing at this point, only add the drawing internally to the keyframe without side-effects. // We wait for the complete keyframe to be parsed and ready, and then merge-insert it into the existing collection. // The drawing post-initialization will only be done at that point. // This prevents doing post-initializations too early when the keyframe is not yet added to the metadata collection. bool isEmpty = r.IsEmptyElement; r.ReadStartElement(); if (isEmpty) { return; } while (r.NodeType == XmlNodeType.Element) { AbstractDrawing drawing = DrawingSerializer.Deserialize(r, scale, TimeHelper.IdentityTimestampMapper, metadata); if (drawing == null || !drawing.IsValid) { continue; } AddDrawing(drawing); drawing.InfosFading.ReferenceTimestamp = this.Position; drawing.InfosFading.AverageTimeStampsPerFrame = metadata.AverageTimeStampsPerFrame; } r.ReadEndElement(); }
public override AbstractDrawing GetNewDrawing(PointF origin, long timestamp, long averageTimeStampsPerFrame, IImageToViewportTransformer transformer) { // Drawings constructors must conforms to one of two predefined prototypes: // (PointF origin, long timestamp, long averageTimeStampsPerFrame, DrawingStyle preset = null, IImageToViewportTransformer transformer = null). // (PointF origin, long timestamp, long averageTimeStampsPerFrame, DrawingStyle stylePreset). // Exemple for 1: DrawingAngle. // Exemple for 2: DrawingText. ConstructorInfo ci = drawingType.GetConstructor(new[] { typeof(PointF), typeof(long), typeof(long), typeof(DrawingStyle), typeof(IImageToViewportTransformer) }); if (ci != null) { object[] parameters = new object[] { origin, timestamp, averageTimeStampsPerFrame, currentStyle, transformer }; AbstractDrawing drawing = (AbstractDrawing)Activator.CreateInstance(drawingType, parameters); return(drawing); } ci = drawingType.GetConstructor(new[] { typeof(PointF), typeof(long), typeof(long), typeof(DrawingStyle) }); if (ci != null) { object[] parameters = new object[] { origin, timestamp, averageTimeStampsPerFrame, currentStyle }; AbstractDrawing drawing = (AbstractDrawing)Activator.CreateInstance(drawingType, parameters); return(drawing); } return(null); }
/// <summary> /// General method to add a drawing on a manager (keyframe-attched, chrono, track). /// </summary> public void AddDrawing(Guid managerId, AbstractDrawing drawing) { if (drawing == null) { return; } Keyframe keyframe = GetKeyframe(managerId); if (keyframe != null) { AddDrawing(keyframe, drawing); return; } if (chronoManager.Id == managerId && drawing is DrawingChrono) { AddChrono(drawing as DrawingChrono); return; } if (trackManager.Id == managerId && drawing is DrawingTrack) { AddTrack(drawing as DrawingTrack); return; } }
public void ConfigureDrawing(AbstractDrawing drawing, Action refresh) { Keyframe keyframe = metadata.HitKeyframe; IDecorable decorable = drawing as IDecorable; if (keyframe == null || drawing == null || decorable == null) { return; } HistoryMementoModifyDrawing memento = new HistoryMementoModifyDrawing(metadata, keyframe.Id, drawing.Id, drawing.Name, SerializationFilter.Style); FormConfigureDrawing2 fcd = new FormConfigureDrawing2(decorable, refresh); FormsHelper.Locate(fcd); fcd.ShowDialog(); if (fcd.DialogResult == DialogResult.OK) { memento.UpdateCommandName(drawing.Name); metadata.HistoryStack.PushNewCommand(memento); } fcd.Dispose(); }
/// <summary> /// Returns the id of the keyframe the drawing is attached to. /// </summary> public Guid FindAttachmentKeyframeId(AbstractDrawing drawing) { Keyframe foundKeyframe = null; foreach (Keyframe k in keyframes) { foreach (AbstractDrawing d in k.Drawings) { if (d.Id != drawing.Id) { continue; } foundKeyframe = k; break; } if (foundKeyframe != null) { break; } } return(foundKeyframe == null ? Guid.Empty : foundKeyframe.Id); }
private void AfterDrawingCreation(AbstractDrawing drawing) { // When passing here, it is possible that the drawing has already been initialized. // (for example, for undo of delete, paste or reload from KVA). if (string.IsNullOrEmpty(drawing.Name)) { SetDrawingName(drawing); } if (drawing is IScalable) { ((IScalable)drawing).Scale(this.ImageSize); } if (drawing is ITrackable && AddTrackableDrawingCommand != null) { AddTrackableDrawingCommand.Execute(drawing as ITrackable); } if (drawing is IMeasurable) { IMeasurable measurableDrawing = drawing as IMeasurable; measurableDrawing.CalibrationHelper = calibrationHelper; measurableDrawing.InitializeMeasurableData(trackExtraData); measurableDrawing.ShowMeasurableInfoChanged += MeasurableDrawing_ShowMeasurableInfoChanged; } if (drawing is DrawingDistortionGrid) { DrawingDistortionGrid d = drawing as DrawingDistortionGrid; d.LensCalibrationAsked += LensCalibrationAsked; } }
public AbstractDrawing IsOnExtraDrawing(PointF point, long timestamp) { // Check if the mouse is on one of the drawings not attached to any key image. // Returns the drawing on which we stand (or null if none), and select it on the way. // the caller will then check its type and decide which action to perform. AbstractDrawing result = null; foreach (DrawingChrono chrono in chronoManager.Drawings) { int hit = chrono.HitTest(point, timestamp, calibrationHelper.DistortionHelper, imageTransform, imageTransform.Zooming); if (hit < 0) { continue; } result = chrono; hitDrawing = chrono; break; } if (result != null) { return(result); } foreach (DrawingTrack track in trackManager.Drawings) { int hit = track.HitTest(point, timestamp, calibrationHelper.DistortionHelper, imageTransform, imageTransform.Zooming); if (hit < 0) { continue; } result = track; hitDrawing = track; break; } if (result != null) { return(result); } for (int i = extraDrawings.Count - 1; i >= 0; i--) { AbstractDrawing candidate = extraDrawings[i]; int hitRes = candidate.HitTest(point, timestamp, calibrationHelper.DistortionHelper, imageTransform, imageTransform.Zooming); if (hitRes < 0) { continue; } result = candidate; hitDrawing = candidate; break; } return(result); }
public override void AddImageDrawing(string filename, bool isSvg) { if (!File.Exists(filename)) { return; } view.BeforeAddImageDrawing(); if (frameServer.Metadata.HitKeyframe == null) { return; } AbstractDrawing drawing = null; if (isSvg) { drawing = new DrawingSVG(frameServer.VideoReader.Current.Timestamp, frameServer.VideoReader.Info.AverageTimeStampsPerFrame, filename); } else { drawing = new DrawingBitmap(frameServer.VideoReader.Current.Timestamp, frameServer.VideoReader.Info.AverageTimeStampsPerFrame, filename); } if (drawing != null) { AddDrawingWithMemento(frameServer.Metadata.HitKeyframe.Id, drawing); } }
private void PrepareContextMenuDrawing(AbstractDrawing drawing) { // Add menus depending on drawing capabilities and its own menus. if (drawing == null) { return; } if ((drawing.Caps & DrawingCapabilities.ConfigureColor) == DrawingCapabilities.ConfigureColor || (drawing.Caps & DrawingCapabilities.ConfigureColorSize) == DrawingCapabilities.ConfigureColorSize) { mnuConfigureDrawing.Text = ScreenManagerLang.Generic_ConfigurationElipsis; popMenu.Items.Add(mnuConfigureDrawing); } if ((drawing.Caps & DrawingCapabilities.Opacity) == DrawingCapabilities.Opacity) { popMenu.Items.Add(mnuConfigureOpacity); } popMenu.Items.Add(new ToolStripSeparator()); bool hasExtraMenus = AddDrawingCustomMenus(drawing, popMenu.Items); if (hasExtraMenus) { popMenu.Items.Add(new ToolStripSeparator()); } // TODO: Add copy and paste menu here. popMenu.Items.Add(mnuDeleteDrawing); }
/// <summary> /// Adds a new track drawing. /// </summary> public void AddTrack(DrawingTrack track) { trackManager.AddDrawing(track); track.ParentMetadata = this; if (lastUsedTrackerParameters != null) { track.TrackerParameters = lastUsedTrackerParameters; } track.TrackerParametersChanged += Track_TrackerParametersChanged; hitDrawing = track; AfterDrawingCreation(track); // The following is necessary for the "undo of deletion" case. track.UpdateKinematics(); track.IntegrateKeyframes(); if (DrawingAdded != null) { DrawingAdded(this, new DrawingEventArgs(track, trackManager.Id)); } }
public override void AddDrawing(AbstractDrawing drawing) { if (!(drawing is DrawingChrono)) { return; } drawings.Add(drawing); }
public FormConfigureVisibility(AbstractDrawing drawing, Control screen) { this.drawing = drawing; this.surfaceScreen = screen; this.memoFading = drawing.InfosFading.Clone(); InitializeComponent(); Populate(); }
private InfosFading m_MemoInfosFading; // Memo to fallback to on cancel. #endregion #region Construction & Initialization public formConfigureOpacity(AbstractDrawing _drawing, PictureBox _SurfaceScreen) { m_SurfaceScreen = _SurfaceScreen; m_Drawing = _drawing; m_MemoInfosFading = _drawing.InfosFading.Clone(); InitializeComponent(); ConfigureForm(); LocalizeForm(); }
private void AddDrawingWithMemento(Guid managerId, AbstractDrawing drawing) { // Temporary function. // Once the player screen ui uses the viewport, this event handler should be removed. // The code here should also be in the metadata manipulator until this function is removed. HistoryMemento memento = new HistoryMementoAddDrawing(frameServer.Metadata, managerId, drawing.Id, drawing.ToolDisplayName); frameServer.Metadata.AddDrawing(managerId, drawing); historyStack.PushNewCommand(memento); }
public override HistoryMemento PerformUndo() { HistoryMemento redoMemento = new HistoryMementoAddDrawing(metadata, managerId, drawingId, drawingName); redoMemento.CommandName = commandName; AbstractDrawing drawing = DrawingSerializer.DeserializeMemento(data, metadata); metadata.AddDrawing(managerId, drawing); return(redoMemento); }
/// <summary> /// Get the precision cursor to use while manipulating the object. /// </summary> public Cursor GetManipulationCursor(AbstractDrawing drawing) { IDecorable decorable = drawing as IDecorable; if (decorable == null) { return(GetCursorPrecision(null, false)); } return(GetCursorPrecision(decorable.DrawingStyle, false)); }
public formConfigureDrawing(AbstractDrawing _drawing, PictureBox _SurfaceScreen) { // This constructor is called when we will be updating a specific drawing. m_bPreConfigure = false; m_SurfaceScreen = _SurfaceScreen; m_Drawing = _drawing; m_ToolType = m_Drawing.ToolType; m_Drawing.MemorizeDecoration(); SetupForm(); }
public override void AddDrawing(AbstractDrawing drawing) { // insert to the top of z-order except for grids. if (drawing is DrawingPlane) { drawings.Add(drawing); } else { drawings.Insert(0, drawing); } }
/// <summary> /// Adds a new chronometer drawing. /// </summary> public void AddChrono(DrawingChrono chrono) { chronoManager.AddDrawing(chrono); chrono.ParentMetadata = this; hitDrawing = chrono; AfterDrawingCreation(chrono); if (DrawingAdded != null) { DrawingAdded(this, new DrawingEventArgs(chrono, chronoManager.Id)); } }
private void ParseTracks(XmlReader r, PointF scale) { // TODO: catch empty tag <Tracks/>. r.ReadStartElement(); while (r.NodeType == XmlNodeType.Element) { AbstractDrawing drawing = DrawingSerializer.Deserialize(r, scale, RemapTimestamp, metadata); metadata.AddDrawing(metadata.TrackManager.Id, drawing); } r.ReadEndElement(); }
private void ParseChronos(XmlReader r, PointF scale) { // TODO: catch empty tag <Chronos/>. r.ReadStartElement(); while (r.NodeType == XmlNodeType.Element) { AbstractDrawing drawing = DrawingSerializer.Deserialize(r, scale, TimeHelper.IdentityTimestampMapper, metadata); metadata.AddDrawing(metadata.ChronoManager.Id, drawing); } r.ReadEndElement(); }
public CommandDeleteDrawing(Action _invalidate, Metadata _Metadata, long _iFramePosition, int _iDrawingIndex) { m_DoScreenInvalidate = _invalidate; m_iFramePosition = _iFramePosition; m_Metadata = _Metadata; m_iDrawingIndex = _iDrawingIndex; int iIndex = GetKeyframeIndex(); if (iIndex >= 0) { m_Drawing = m_Metadata[iIndex].Drawings[m_iDrawingIndex]; } }
public static AbstractDrawing Deserialize(XmlReader r, PointF scaling, TimestampMapper timestampMapper, Metadata metadata) { AbstractDrawing drawing = null; if (r.IsEmptyElement) { r.ReadStartElement(); return(null); } // Find the right class to instanciate. // The class must derive from AbstractDrawing and have the corresponding [XmlType] C# attribute. bool drawingRead = false; Assembly a = Assembly.GetExecutingAssembly(); foreach (Type t in a.GetTypes()) { if (t.BaseType != typeof(AbstractDrawing)) { continue; } object[] attributes = t.GetCustomAttributes(typeof(XmlTypeAttribute), false); if (attributes.Length <= 0 || ((XmlTypeAttribute)attributes[0]).TypeName != r.Name) { continue; } ConstructorInfo ci = t.GetConstructor(new[] { typeof(XmlReader), typeof(PointF), typeof(TimestampMapper), typeof(Metadata) }); if (ci == null) { break; } object[] parameters = new object[] { r, scaling, timestampMapper, metadata }; drawing = (AbstractDrawing)Activator.CreateInstance(t, parameters); drawingRead = drawing != null; break; } if (!drawingRead) { string unparsed = r.ReadOuterXml(); log.DebugFormat("Unparsed content in KVA XML: {0}", unparsed); } return(drawing); }
public void DeleteHitDrawing() { Keyframe keyframe = metadata.HitKeyframe; AbstractDrawing drawing = metadata.HitDrawing; if (keyframe == null || drawing == null) { return; } HistoryMemento memento = new HistoryMementoDeleteDrawing(metadata, keyframe.Id, drawing.Id, drawing.ToolDisplayName); metadata.DeleteDrawing(keyframe.Id, drawing.Id); metadata.HistoryStack.PushNewCommand(memento); }
public CommandAddDrawing(DelegateScreenInvalidate _invalidate, DelegateDrawingUndrawn _undrawn, Metadata _Metadata, long _iFramePosition) { m_DoInvalidate = _invalidate; m_DoUndrawn = _undrawn; m_iFramePosition = _iFramePosition; m_Metadata = _Metadata; int iIndex = GetKeyframeIndex(); if (iIndex >= 0) { m_iTotalDrawings = m_Metadata[iIndex].Drawings.Count; m_Drawing = m_Metadata[iIndex].Drawings[0]; } }
public void ModifiedDrawing(Guid managerId, Guid drawingId) { AbstractDrawing drawing = GetDrawing(managerId, drawingId); DrawingTrack track = drawing as DrawingTrack; if (track != null) { track.UpdateKinematics(); track.IntegrateKeyframes(); } if (DrawingModified != null) { DrawingModified(this, new DrawingEventArgs(drawing, managerId)); } }
public void ShowDataAnalysis(AbstractDrawing drawing) { /*if (drawing is DrawingCrossMark) * { * FormPointsAnalysis fpa = new FormPointsAnalysis(frameServer.Metadata); * FormsHelper.Locate(fpa); * fpa.ShowDialog(); * fpa.Dispose(); * } * else if (drawing is DrawingTrack) * { * FormTrackAnalysis fta = new FormTrackAnalysis(frameServer.Metadata, drawing as DrawingTrack); * FormsHelper.Locate(fta); * fta.ShowDialog(); * fta.Dispose(); * }*/ }
public void DeleteDrawing(Guid managerId, Guid drawingId) { // Remove event handlers from the drawing as well as all associated data like tracking data, // and finally remove the drawing itself. AbstractDrawingManager manager = null; if (managerId == chronoManager.Id) { manager = chronoManager; } else if (managerId == trackManager.Id) { manager = trackManager; } else { manager = GetKeyframe(managerId); } if (manager == null) { return; } AbstractDrawing drawing = manager.GetDrawing(drawingId); if (drawing == null) { return; } BeforeDrawingDeletion(drawing); manager.RemoveDrawing(drawingId); UnselectAll(); if (DrawingDeleted != null) { DrawingDeleted(this, EventArgs.Empty); } }
private void SetDrawingName(AbstractDrawing drawing) { // Use a unique name based on drawing type. string toolDisplayName = drawing.ToolDisplayName; int index = 1; bool done = false; string name = ""; while (!done) { name = string.Format("{0} {1}", toolDisplayName, index); if (!IsNameTaken(name)) { break; } index++; } drawing.Name = name; }
/// <summary> /// Adds a drawing to the specified keyframe. /// </summary> public void AddDrawing(Keyframe keyframe, AbstractDrawing drawing) { if (keyframe == null || drawing == null || !drawing.IsValid) { return; } keyframe.AddDrawing(drawing); drawing.InfosFading.ReferenceTimestamp = keyframe.Position; drawing.InfosFading.AverageTimeStampsPerFrame = averageTimeStampsPerFrame; SelectKeyframe(keyframe); SelectDrawing(drawing); AfterDrawingCreation(drawing); if (DrawingAdded != null) { DrawingAdded(this, new DrawingEventArgs(drawing, keyframe.Id)); } }