```
I = imread('cameraman.tif');
figure, imshow(I, [])
hold on;
plot(118, 61, 'or', 'markersize', 35, 'markerfacecolor', 'r');
```

Looks good you think. Go ahead and make it in a loop to create video. If you do and you have at least a 5 minutes video, then you'd just freed your afternoon. This is about how long it will take.

### For the inpatient
The summary of this post is the reference to one of Matlab's functions. [insertShape](https://se.mathworks.com/help/vision/ref/insertshape.html) available from R2014a. Have a look. Below I just explain why you should really use `insertShape`.

### Moving on
Let's measure the time of Matlab's code for a fun. I have a test video, which is 1920x1090 MPEG-4 H264 video. Let's make a new one with a constant circle.
```
source = VideoReader('test.mp4');
dst = VideoWriter('test-naive', 'MPEG-4');
dst.FrameRate = source.FrameRate;

open(dst)

fprintf('Started on %s\n', datestr(now));
tic;
try
while hasFrame(source)
vidFrame = readFrame(source);
imshow(vidFrame);
hold on;
plot(100, 100, 'or', 'MarkerSize', 50, 'MarkerFaceColor', 'r');
hold off;

writeVideo(dst, getframe(gcf));
end
catch ME
% no error handling, just display the exception
ME
end
elapsedTime = toc;
fprintf('Finished on %s\n', datestr(now));
fprintf('Tic/toc measure is %f sec\n', elapsedTime);

clear readerObj;
close(dst);
```

And the results are
```
Started on 16-Apr-2018 19:42:17
Warning: Image is too big to fit on screen; displaying at 67%
> In images.internal.initSize (line 71)
In imshow (line 336)
In videoNaive (line 18)
Finished on 16-Apr-2018 19:51:31
Tic/toc measure is 554.421488 sec
```
*I will get to the warning later.*
Almost 10 minutes! OK. Not much for a free afternoon, but perhaps still quite some time for such a tiny job. I run that test on Windows 10 x64 machine with both integrated and dedicated graphics card (used simultaneously) and in Matlab R2018a. Not that the specs matter that much as I did tests on different machines and the results were similar.

To illustrate how fast can it be, let's use Python to do the same thing. I won't go into details about setting your Python environment up. You will need working openCV and numPy in order to run the example code.

```
## Visualize tracker
import numpy as np
import cv2
import os
from datetime import datetime

rawVideo = 'test.mp4'
outVideo = 'test_python.avi'
markerSize = 9
frameCounter = -1

cap = cv2.VideoCapture(rawVideo)
fourcc = cv2.VideoWriter_fourcc(*'X264')
out = cv2.VideoWriter(outVideo, fourcc, 25.0, (1920,1080))

if not cap.isOpened():
print('Cap is not opened')

print("Started at {0}".format(datetime.now().time()))

while (cap.isOpened()):
ret, frame = cap.read()
frameCounter += 1
if ret == False:
break

x = int(100)
y = int(100)
cv2.circle(frame, (x, y), markerSize, (0, 0, 240), -1)

out.write(frame)

print("Ended at {0}".format(datetime.now().time()))
cap.release()
out.release()
cv2.destroyAllWindows()
print('done')
```

And the output is
```
Started at 20:20.12.771219
Ended at 20:21:43.550657
```
**WHAT?!** One and a half minute it is!

By observing the code you can see the obvious difference: Python doesn't display the image to user, whereas Matlab displays the image, plots on top, grabs the frame from what has been displayed, writes the frame. Of course it is inefficient. Matlab's Computer Vision Systems Toolbox has a function to deal with such situations. It's named [insertShape](https://se.mathworks.com/help/vision/ref/insertshape.html) and it first appeared in R2014a.

Let's see how it looks with that function.
```
source = VideoReader('test.mp4');
dst = VideoWriter('test-insertShape', 'MPEG-4');
dst.FrameRate = source.FrameRate;

open(dst)
curAxes = axes;
hold on;
set(curAxes, 'nextplot', 'replacechildren');

fprintf('Started on %s\n', datestr(now));
tic;
try
while hasFrame(source)
vidFrame = readFrame(source);
vidFrame = insertShape(vidFrame, 'FilledCircle', [100 100 50], 'Color', 'red', 'Opacity', 1);
writeVideo(dst, vidFrame);
end
catch ME
% no error handling, just display the exception
ME
end
elapsedTime = toc;
fprintf('Finished on %s\n', datestr(now));
fprintf('Tic/toc measure is %f sec\n', elapsedTime);

clear readerObj;
close(dst);
```

And the results are

```
Started on 16-Apr-2018 20:33:14
Finished on 16-Apr-2018 20:36:12
Tic/toc measure is 177.690809 sec
```

That's the way to go! 3 minutes, which is still longer than Python version, but obviously much better than the original *hold on* version.

*Bonus*.
Remember that warning from the first version of Matlab's code? If you watch the video, you will see that it is not your original 1920x1080. In my case, it is 1454x814 with space around the frame (the regular Matlab image saving artifacts). However, code with `insertShape` produced a video as we would expect it to do.

EasyGUI handles all the boilerplate for you. You want a value, you get the value.

EasyGUI is a classic abandonware. It has been written in pre R2014b era (it's first version dates back to 2009). R2018a is the current Matlab release as of the time of writing. EasyGUI has no maintenance support, but seems like people still try to use it since it had been MATLAB Central [pick of the week](https://blogs.mathworks.com/pick/2009/03/06/gui-layout-part-5/). If you read EasyGUI's latest comments on File Exchange, you will see people say EasyGUI does not work. When I first tried it, I had exactly the same problem as others: I followed the example, fixed some string case errors and ended up with a figure without any controls. Or at least without any visible controls. I could just move on to another toolbox, but at the same time I was tempted to figure out what was wrong with it. And I wanted to use EasyGUI in a small program I had to write anyway.

EasyGUI uses an undocumented control [uiflowcontainer](https://undocumentedmatlab.com/blog/matlab-layout-managers-uicontainer-and-relatives) under the hood. When you create, say a slider, several controls are created. Important stuff: uiflowcontainer is used as a container, the rest of widgets are created as it's children. Uiflowcontainer by itself a child of some other container. EasyGUI uses classes, events, interfaces, custom position class and it might be hard to figure out what happens where. On top of it comes good encapsulation. Internal variables are marked as private and you can't inspect them from outside (unless you modify the code, of course).

The confusing no widgets situation happens when people follow an example and use autogui widget. Autogui creates a layout and maintains position of all of its children. Here is the layout hierarchy from the source code of autogui:

UiHandle
  UiMainContainer [uiflowcontainer] - contains guiarea & plotarea
     UiPlotArea [uipanel]
     UiGuiArea [uipanel]
         UiGuiPanelGroup [uiflowcontainer]
            UiCurrentGuiPanel [uiflowcontainer]

UiGuiPanelGroup can have multiple children whereas the currently active panel is referenced through UiCurrentGuiPanel. When all these panels are created, there are no widgets assigned to them. EasyGUI resizes UiGuiArea/UiGuiPanelGroup to be 1x1 pixel. When a new widget is added to UiCurrentGuiPanel, it is expanded to accommodate the new widget. Let's have a look at it's size at different stages. Here is the code in R2017b:

>> mg = gui.autogui;
>> fprintf('UiGuiPanelGroup before any widgets\n\tPosition: [%u %u %u %u], HeightLimits: [%u %u]\n', get(mg.UiGuiPanelGroup, 'Position'), get(mg.UiGuiPanelGroup, 'HeightLimits'));
UiGuiPanelGroup before any widgets
    Position: [1 1 556 416]
>> mass = gui.slider('mass', [10 20], mg);
>> fprintf('UiGuiPanelGroup after adding one widget\n\tPosition: [%u %u %u %u]\n', get(mg.UiGuiPanelGroup, 'Position'));
UiGuiPanelGroup after adding one widget
    Position: [1 1 556 416]

And the same code in 2014a:

>> mg = gui.autogui;
>> fprintf('UiGuiPanelGroup before any widgets\n\tPosition: [%u %u %u %u]\n', get(mg.UiGuiPanelGroup, 'Position'));
 UiGuiPanelGroup after adding one widget
    Position: [1 1 201 0]
>> mass = gui.slider('mass', [10 20], mg);
>> fprintf('UiGuiPanelGroup after adding one widget\n\tPosition: [%u %u %u %u]\n', get(mg.UiGuiPanelGroup, 'Position'));
UiGuiPanelGroup after adding one widget
    Position: [1 1 201 56]

Now, you see that in R2017b height is big right from the beginning. Height is adjusted dynamically in R2014a. I think it works correctly in R2014b because of figure visibility set to off (and some internal Matlab processing of invisible figures). If one adds a single fprintf, that accesses UiGuiPanelGroup position inside the constructor of gui.autogui, then the whole thing stops working! Here it is:

>> mg = gui.autogui;
Position of UiGuiPanelGroup right after creation: [1 1 556 416]

So the problem is that panel is too tall, widgets are placed outside the main figure. Hence they are invisible to user.

Without going any much deeper into it, there are several ways to change the above behaviour:

1. Make UiGuiPanelGroup height appropriate right from the beginning and change it only if the main container's height is changed.
2. Dynamically change UiGuiPanelGroup whenever UiGuiArea is changed.
3. Do not do any size management, introduce a dependency from a different layout library. For example, one can use [GUI Layout Toolbox](https://se.mathworks.com/matlabcentral/fileexchange/47982-gui-layout-toolbox). However, some size management can still be needed.
4. Use normalized units instead of pixels. This will ensure that children are updated when parent is resized.

As I wanted a quick fix I decided to go with 2. The code available on [GitHub](https://github.com/kavli-ntnu/EasyGUI) and [File Exchange](http://se.mathworks.com/matlabcentral/fileexchange/66728-easygui). Note that I didn't improve the overall structure of the toolbox by modern standards. There is no packaging, tests, and good documentation.

Bonus

Label widget allows to control top and bottom margin. However, top/bottom margins seems to be swapped. This is fixed as well.

Bonus 2

Widgets appear to be clipped at the bottom. This is the consequence of internal size management. I fixed it as well.

I think that the library still needs a good code refactoring. Just have a look at this nice bug in the original version happening when user changes widget's label location multiple times in a row.

If anyone interested in contributing, you know where the source code is. The license is EasyGUI's original license, which resembles MIT to me. However, as people do say in such cases - this is not a legal advise, consult your lawyer if needed.

now I will post there. Hope it is the last change of the posting place.

Here comes the Poker

to be continued...

центральная площадь Мариенплатц

Там же.

Mit herzlichem Gruß ;)