2 | % md5hash Calculate 128 bit MD5 checksum
3 | %
4 | % This function calculates a 128 bit checksum for arrays and files.
5 | %
6 | % Input:
7 | % - data (matrix, string): Data array or file name. Either numerical or CHAR array.
8 | % Currently only files and arrays with up to 2^32 bytes (2.1GB) are
9 | % accepted.
10 | % - input (string): Type of the input, optional. Default: 'Char'.
11 | % 'File': Data is a file name as string. The digest is calculated
12 | % for this file.
13 | % 'Char': Data is a char array to calculate the digest for. Only the
14 | % ASCII part of the Matlab CHARs is used, such that the digest
15 | % is the same as if the array is written to a file as UCHAR,
16 | % e.g. with FWRITE.
17 | % 'Unicode': All bytes of the input are used to calculate the
18 | % digest. This is the standard for numerical input.
19 | % - output (string, optional): Format of the output. Just the first character matters.
20 | % Optional, default: 'hex'.
21 | % - 'hex': [1 x 32] string as lowercase hexadecimal number.
22 | % - 'HEX': [1 x 32] string as uppercase hexadecimal number.
23 | % - 'Dec': [1 x 16] double vector with UINT8 values.
24 | % - 'Base64': [1 x 22] string, encoded to base 64 (A:Z,a:z,0:9,+,/).
25 | %
26 | % Output:
27 | % - hash: A 128 bit number is replied in a format depending on output parameter.
28 | % The chance, that different data sets have the same MD5 sum is about
29 | % 2^128 (> 3.4 * 10^38). Therefore MD5 can be used as "finger-print"
30 | % of a file rather than e.g. CRC32.
31 | %
32 | % Examples:
33 | % Three methods to get the MD5 of a file:
34 | % 1. Direct file access (recommended):
35 | % MD5 = CalcMD5(which('CalcMD5.m'), 'File')
36 | % 2. Import the file to a CHAR array (binary mode for exact line breaks!):
37 | % FID = fopen(which('CalcMD5.m'), 'rb');
38 | % S = fread(FID, inf, 'uchar=>char');
39 | % fclose(FID);
40 | % MD5 = CalcMD5(S, 'char')
41 | % 3. Import file as a byte stream:
42 | % FID = fopen(which('CalcMD5.m'), 'rb');
43 | % S = fread(FID, inf, 'uint8=>uint8');
44 | % fclose(FID);
45 | % MD5 = CalcMD5(S, 'unicode'); // 'unicode' can be omitted here
46 | %
47 | % Author: Jan Simon, Heidelberg, (C) 2009-2010 J@n-Simon.De
48 | % License: This program is derived from the RSA Data Security, Inc.
49 | % MD5 Message Digest Algorithm, RFC 1321, R. Rivest, April 1992
50 | %
51 |
52 | % If the current Matlab path is the parent folder of this script, the
53 | % MEX function is not found - change the current directory!
54 | error(['JSim:', mfilename, ':NoMex'], 'Cannot find MEX script.');
55 |
56 |
--------------------------------------------------------------------------------
/vot-toolkit-master/report/report_sequences_preview.m:
--------------------------------------------------------------------------------
1 | function [document] = report_sequences_preview(context, sequences, varargin)
2 | % report_sequences_preview Create an overview document for the given sequences
3 | %
4 | % The function generates a report document for the given sequences by providing a
5 | % preview of each sequence.
6 | %
7 | % Input:
8 | % - context (structure): A report context structure.
9 | % - sequences (cell): An array of sequence descriptors.
10 | % - varargin[Frames] (integer): Number of frames for each sequence to present in a strip.
11 | %
12 | % Output:
13 | % - document (structure): A document structure.
14 | %
15 |
16 | document = create_document(context, 'sequences', 'title', 'Sequences overview');
17 |
18 | frames = 6;
19 |
20 | for i = 1:2:length(varargin)
21 | switch lower(varargin{i})
22 | case 'frames'
23 | frames = varargin{i+1};
24 | otherwise
25 | error(['Unknown switch ', varargin{i}, '!']) ;
26 | end
27 | end
28 |
29 | tags = {'empty'};
30 | total_size = 0;
31 |
32 | for s = 1:length(sequences)
33 | tags = union(tags, sequences{s}.tags.names);
34 | total_size = total_size + sequences{s}.length;
35 | end;
36 |
37 | document.raw('Total size: %d sequences, %d frames', numel(sequences), total_size);
38 |
39 | if ~isempty(tags)
40 |
41 | document.section('Tags distribution');
42 |
43 | tags_count = zeros(numel(tags), 1);
44 |
45 | for s = 1:length(sequences)
46 | for l = 1:length(tags)
47 | tags_count(l) = tags_count(l) + numel(query_tag(sequences{s}, tags{l}));
48 | end;
49 | end;
50 |
51 | handle = generate_plot('title', 'Tags distribution');
52 |
53 | bar(tags_count ./ total_size);
54 | set(gca, 'TickLabelInterpreter', 'none');
55 | set(gca, 'XTickLabel', tags);
56 |
57 | document.figure(handle, 'tagss_distribution', 'Tags distribution');
58 |
59 | close(handle);
60 |
61 | document.subsection('Tags in sequences');
62 |
63 | for l = 1:length(tags)
64 | subset = cellfun(@(s) ~isempty(sequence_query_tag(s, tags{l})), sequences, 'UniformOutput', true);
65 | document.text('Tag %s: %s', tags{l}, strjoin(cellfun(@(s) s.name, sequences(subset), 'UniformOutput', false), ', '));
66 | end;
67 |
68 | end;
69 |
70 | for s = 1:length(sequences)
71 |
72 | print_indent(1);
73 |
74 | print_text('Processing sequence %s ...', sequences{s}.name);
75 |
76 | document.raw('\n');
77 |
78 | figure_id = sprintf('sequence_preview_%s', sequences{s}.name);
79 |
80 | document.figure(@() generate_sequence_strip(sequences{s}, {}, 'samples', frames, 'window', Inf), ...
81 | figure_id, sprintf('Sequence %s', sequences{s}.name));
82 |
83 | document.raw('
\n');
84 |
85 | print_indent(-1);
86 |
87 | end;
88 |
89 | document.write();
90 |
91 |
92 |
93 |
--------------------------------------------------------------------------------
/vot-toolkit-master/report/generate_plot.m:
--------------------------------------------------------------------------------
1 | function handle = generate_plot(varargin)
2 | % generate_plot Generate an blank plot
3 | %
4 | % The function creates and configures an new plot that can be then populated.
5 | %
6 | % Input:
7 | % - varargin[Title] (string): A title of the plot.
8 | % - varargin[Visible] (boolean): Is the figure visible on the display.
9 | % - varargin[Width] (double): Figure width hint.
10 | % - varargin[Height] (double): Figure height hint.
11 | % - varargin[Box] (boolean): Enable axis box
12 | % - varargin[Grid] (boolean): Enable axis grid
13 | % - varargin[Handle] (handle): Plot on existing figure handle.
14 | % - varargin (other): Forward parameters to axis settings.
15 | %
16 | % Output:
17 | % - handle (handle): A figure handle.
18 | %
19 |
20 | plot_title = [];
21 | visible = false;
22 | width = 4;
23 | height = 4;
24 | axis_box = true;
25 | axis_grid = true;
26 | handle = [];
27 | axis_settings = {};
28 |
29 | for i = 1:2:length(varargin)
30 | switch lower(varargin{i})
31 | case 'title'
32 | plot_title = varargin{i+1};
33 | case 'visible'
34 | visible = varargin{i+1};
35 | case 'width'
36 | width = varargin{i+1};
37 | case 'height'
38 | height = varargin{i+1};
39 | case 'box'
40 | axis_box = varargin{i+1};
41 | case 'grid'
42 | axis_grid = varargin{i+1};
43 | case 'handle'
44 | handle = varargin{i+1};
45 | otherwise
46 | axis_settings{end+1} = varargin{i}; %#ok
47 | axis_settings{end+1} = varargin{i+1}; %#ok
48 | end
49 | end
50 |
51 | if ~isempty(handle) && ishandle(handle)
52 | if strcmp(get(handle, 'type'),'figure')
53 | figure(handle);
54 | elseif strcmp(get(handle, 'type'),'axes')
55 | axes(handle);
56 | else
57 | handle = [];
58 | end
59 | else
60 | handle = [];
61 | end
62 |
63 | if isempty(handle)
64 | if ~visible
65 | handle = figure('Visible', 'off');
66 | else
67 | handle = figure();
68 | end
69 | end;
70 |
71 | hold on;
72 | if axis_box
73 | box on;
74 | end;
75 | if axis_grid
76 | grid on;
77 | end
78 |
79 | if ~isempty(plot_title)
80 | title(plot_title, 'interpreter', 'none');
81 | end;
82 |
83 | if ~isempty(axis_settings)
84 | set(gca, axis_settings{:});
85 | end;
86 |
87 | if strcmp(get(handle, 'type'),'figure')
88 | set(handle, 'PaperUnits', 'inches', 'PaperSize', [width, height], 'PaperPosition', [0, 0, width, height]);
89 | end;
90 |
91 | hold off;
92 |
93 | end
94 |
--------------------------------------------------------------------------------
/vot-toolkit-master/tracker/tracker_list.m:
--------------------------------------------------------------------------------
1 | function [trackers] = tracker_list(varargin)
2 | % tracker_list Creates a set of tracker descriptor structures
3 | %
4 | % Create a cell array of new tracker structures from identifiers or file lists of identifiers.
5 | %
6 | % This functions checks each argument if it is a valid file and openes it as a text file of
7 | % comma and new line separated tracker identifiers. If an argument is not a file then it is
8 | % considered an identifier.
9 | %
10 | % Examples:
11 | %
12 | % trackers = tracker_list('trackers.txt', 'NCC'); % Load tracker identifiers from file trackers.txt and add a tracker NCC
13 | %
14 | % Input:
15 | % - varargin: A list of strings denoting either files containing tracker identifiers or valid identifiers. See `valid_identifier` for more details.
16 | %
17 | % Output:
18 | % - trackers: A cell array of new tracker structures.
19 |
20 | identifiers = {};
21 |
22 | for j = 1:nargin
23 |
24 | %check if the first argument is a file, if so it is a
25 | %text file containing a list of tracker names, ignore directories
26 | %(since the results folder migtht be on the path)
27 | if file_exist(fullfile(pwd(), varargin{j}))
28 |
29 | ids = parsefile(fullfile(pwd(), varargin{j}), 'Delimiter', ',');
30 |
31 | identifiers = [identifiers; ids(:)]; %#ok
32 |
33 | else
34 |
35 | % if the argument is not a file name, but it is still a string ...
36 | if ischar(varargin{j})
37 | identifiers = [identifiers; varargin(j)]; %#ok
38 | end;
39 |
40 | end;
41 |
42 | end;
43 |
44 | % remove the duplicate identifiers
45 | if is_octave
46 | identifiers = unique(identifiers);
47 | print_debug('Warning: Tracker order is not preserved due to Octave limitations.')
48 | else
49 | identifiers = unique(identifiers, 'stable');
50 | end;
51 |
52 | trackers = cell(size(identifiers, 1), 1);
53 |
54 | for i = 1:size(identifiers, 1)
55 | tracker_identifier = strtrim(identifiers{i});
56 |
57 | if isempty(tracker_identifier)
58 | break;
59 | end
60 |
61 | trackers{i} = tracker_load(tracker_identifier);
62 |
63 | end;
64 |
65 | trackers = set_trackers_visual_identity(trackers);
66 |
67 | end
68 |
69 | % Matlab exist function is very flexible but also confuses script names for
70 | % real files, therefore "ncc" will be considered a file if a file "ncc.m" exists
71 | % in Matlab path. This can be problematic in our scenario. Therefore this function
72 | % approaches the problem in a plain C way.
73 | function status = file_exist(file_path)
74 |
75 | fd = fopen(file_path, 'r');
76 |
77 | status = fd > 0;
78 |
79 | if (fd > 0)
80 | fclose(fd);
81 | end;
82 | end
83 |
84 |
--------------------------------------------------------------------------------
/vot-toolkit-master/analysis/estimate_accuracy.m:
--------------------------------------------------------------------------------
1 | function [accuracy, frames] = estimate_accuracy(trajectory, sequence, varargin)
2 | % estimate_accuracy Calculate accuracy score
3 | %
4 | % Calculate accuracy score as average overlap over the entire sequence.
5 | %
6 | % Input:
7 | % - trajectory (cell): A trajectory as a cell array of regions.
8 | % - sequence (cell or structure): Can be another trajectory or a valid sequence descriptor.
9 | % - varargin[Burnin] (integer): Number of frames that have to be ignored after the failure.
10 | % - varargin[IgnoreUnknown] (boolean): Ignore frames where the overlap is
11 | % unknown.
12 | % - varargin[BindWithin] (boolean or vector): Bind the overlap calculation to the region
13 | % within the image. If the sequence variable is a sequence structure then a boolean value
14 | % is sufficient to establishe bounding region. Otherwise a bounding region has to be specified
15 | % manually.
16 | %
17 | % Output:
18 | % - accuracy (double): Average overlap.
19 | % - frames (double vector): Per-frame overlaps.
20 | %
21 |
22 | ignore_unknown = true;
23 | burnin = 0;
24 | bind_within = get_global_variable('bounded_overlap', true);
25 |
26 | for j=1:2:length(varargin)
27 | switch lower(varargin{j})
28 | case 'burnin', burnin = max(0, varargin{j+1});
29 | case 'ignoreunknown', ignore_unknown = varargin{j+1};
30 | case 'bindwithin', bind_within = varargin{j+1};
31 | otherwise, error(['unrecognized argument ' varargin{j}]);
32 | end
33 | end
34 |
35 | if burnin > 0
36 |
37 | mask = cellfun(@(r) numel(r) == 1 && r == 1, trajectory, 'UniformOutput', true);
38 |
39 | if is_octave()
40 | se = logical([zeros(burnin - 1, 1); ones(burnin, 1)]);
41 | else
42 | se = strel('arbitrary', [zeros(burnin - 1, 1); ones(burnin, 1)]);
43 | end;
44 |
45 | % ignore the next 'burnin' frames
46 | mask = imdilate(mask, se);
47 |
48 | else
49 |
50 | mask = false(size(trajectory, 1), 1);
51 |
52 | end;
53 |
54 | if ~ignore_unknown
55 | unknown = cellfun(@(r) numel(r) == 1 && r == 0, trajectory, 'UniformOutput', true);
56 | end;
57 |
58 | trajectory(mask) = {0};
59 |
60 | if islogical(bind_within)
61 | if bind_within && isstruct(sequence)
62 | bounds = [sequence.width, sequence.height] - 1;
63 | else
64 | bounds = [];
65 | end;
66 | else
67 | bounds = bind_within;
68 | end;
69 |
70 | if isstruct(sequence)
71 | frames = calculate_overlap(trajectory, get_region(sequence, 1:sequence.length), bounds);
72 | else
73 | frames = calculate_overlap(trajectory, sequence, bounds);
74 | end;
75 |
76 | if ~ignore_unknown
77 | frames(unknown) = 0;
78 | end;
79 |
80 | overlap = frames(~isnan(frames)); % filter-out illegal values
81 |
82 | % Handle cases, where no overlap is available
83 | if isempty(overlap)
84 | accuracy = 0;
85 | else
86 | accuracy = mean(overlap);
87 | end;
88 |
--------------------------------------------------------------------------------
/vot-toolkit-master/sequence/write_trajectory.cpp:
--------------------------------------------------------------------------------
1 |
2 | #include
3 |
4 | #include "mex.h"
5 | #include "region.h"
6 |
7 | char* getString(const mxArray *arg) {
8 |
9 | if (mxGetM(arg) != 1)
10 | mexErrMsgTxt("Must be a string");
11 |
12 | int l = mxGetN(arg);
13 |
14 | char* str = (char *) malloc(sizeof(char) * (l + 1));
15 |
16 | mxGetString(arg, str, (l + 1));
17 |
18 | return str;
19 | }
20 |
21 | void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
22 |
23 | region_container** regions = NULL;
24 |
25 | if( nrhs != 2 ) mexErrMsgTxt("Exactly one string input argument and one cell array argument required.");
26 | if( nlhs != 0 ) mexErrMsgTxt("No output arguments required.");
27 |
28 | char* path = getString(prhs[0]);
29 |
30 | if (!mxIsCell(prhs[1]))
31 | mexErrMsgTxt("Second argument must be a cell array");
32 |
33 | int length = MAX(mxGetM(prhs[1]), mxGetN(prhs[1]));
34 |
35 | if ( MIN(mxGetM(prhs[1]), mxGetN(prhs[1])) != 1 )
36 | mexErrMsgTxt("Cell array must be a vector");
37 |
38 | regions = (region_container**) malloc(sizeof(region_container*) * length);
39 |
40 | for (int i = 0; i < length; i++) {
41 |
42 | mxArray* val = mxGetCell (prhs[1], i);
43 |
44 | region_container* region = NULL;
45 |
46 | if (val) {
47 |
48 | double *d = (double*) mxGetPr(val);
49 | int l = MAX(mxGetM(val), mxGetN(val));
50 |
51 | if (!mxIsEmpty(val) && MIN(mxGetM(val), mxGetN(val)) == 1) {
52 |
53 | if (l == 1) {
54 |
55 | region = region_create_special(d[0]);
56 |
57 | } else if (l == 4) {
58 |
59 | region = region_create_rectangle(d[0], d[1], d[2], d[3]);
60 |
61 | } else if (l > 5 && l % 2 == 0) {
62 |
63 | region = region_create_polygon(l / 2);
64 |
65 | for (int j = 0; j < l / 2; j++) {
66 | region->data.polygon.x[j] = d[j * 2];
67 | region->data.polygon.y[j] = d[j * 2 + 1];
68 | }
69 | }
70 |
71 | }
72 |
73 | }
74 |
75 | if (region) {
76 | regions[i] = region;
77 | } else {
78 | char message[128];
79 | sprintf(message, "Not a valid region at position %d, skipping", i+1);
80 | mexWarnMsgTxt(message);
81 | regions[i] = region_create_special(-1);
82 | }
83 |
84 | }
85 |
86 | FILE* fp = fopen(path, "w");
87 |
88 | if (fp != NULL) {
89 |
90 | for (int i = 0; i < length; i++) {
91 |
92 | region_container* region = regions[i];
93 |
94 | char* tmp = region_string(region);
95 |
96 | if (tmp) {
97 | fputs(tmp, fp);
98 | fputc('\n', fp);
99 | free(tmp);
100 | }
101 |
102 | region_release(®ion);
103 |
104 | }
105 |
106 | } else {
107 |
108 | free(path);
109 | mexErrMsgTxt("Unable to open file for writing.");
110 | }
111 |
112 | if (regions)
113 | free(regions);
114 |
115 | fclose(fp);
116 | free(path);
117 | }
118 |
119 |
--------------------------------------------------------------------------------
/vot-toolkit-master/report/resources/js/layout.js:
--------------------------------------------------------------------------------
1 |
2 | $(function () {
3 |
4 | var title = $('h1').first().text();
5 |
6 | $('body').prepend($('').attr('id', 'header')
7 | .append($('').addClass('navbar navbar-default navbar-fixed-top')
8 | .append($('').addClass('container')
9 | .append($('').addClass('navbar-header')
10 | .append($('').addClass('navbar-brand').text(title).attr('href', '#'))))));
11 |
12 | var modal = Object;
13 | modal.wrapper = $('').addClass('modal').attr('tabindex', '-1');
14 | modal.dialog = $('').addClass('modal-dialog modal-lg').appendTo(modal.wrapper);
15 | modal.content = $('').addClass('modal-content').appendTo(modal.dialog);
16 | modal.header = $('').addClass('modal-header').appendTo(modal.content);
17 | modal.title = $('').appendTo(modal.header);
18 | modal.header.append($(''));
19 | modal.body = $('').addClass('modal-body').appendTo(modal.content);
20 | $('body').append(modal.wrapper.modal({'show': false}));
21 |
22 | // Format stacking elements into grid
23 | $('.stacking').each(function(i, candidate) {
24 | candidate = $(candidate);
25 | if (candidate.prev('.stacking').length > 0)
26 | return;
27 |
28 | var sequence = candidate;
29 | var current = candidate;
30 |
31 | for (current = candidate.next('.stacking'); current.length > 0; current = current.next('.stacking')) {
32 | sequence = sequence.add(current);
33 | }
34 |
35 | if (sequence.length < 2)
36 | return;
37 |
38 | var wrapper = $('').addClass("row");
39 |
40 | candidate.before(wrapper);
41 |
42 | sequence.each(function (i, element) {
43 | element = $(element);
44 | element.remove().appendTo($('').addClass('col-md-4').appendTo(wrapper));
45 | });
46 |
47 | });
48 |
49 | $('.image-wrapper img').click(function(event) {
50 |
51 | modal.title.text($(this).parent().find('.title').first().text());
52 |
53 | modal.body.empty().append($(this).clone());
54 |
55 | modal.wrapper.modal('show');
56 |
57 | });
58 |
59 | // Build navigation
60 | var section = null;
61 | var anchorId = 0;
62 |
63 | var menu = $('').addClass('nav navbar-nav').appendTo($('#header .container')).wrap($('').attr('id', 'navbar'));
64 |
65 | $('body > .container h2').each(function(i, header) {
66 | header = $(header);
67 |
68 | section = $('').append($('').attr('href', '#navigation-' + anchorId).text(header.text())).appendTo(menu);
69 |
70 | header.append($('').attr('name', 'navigation-' + anchorId).attr('id', 'navigation-' + anchorId).attr('href', '#'));
71 |
72 | anchorId++;
73 |
74 | });
75 |
76 | $('body').scrollspy({ target: '#navbar' });
77 |
78 | });
79 |
--------------------------------------------------------------------------------
/vot-toolkit-master/utilities/compile_mex.m:
--------------------------------------------------------------------------------
1 | function [success] = compile_mex(name, files, includes, directory, varargin)
2 | % compile_mex Compile given source files to a MEX function
3 | %
4 | % Compiles or recompiles given source files to a MEX function taking
5 | % into account source files timestamps. Also works in Octave by switching
6 | % to mkoctfile command.
7 | %
8 | % Input:
9 | % - name (string): Name of MEX function.
10 | % - files (cell array): Array of source files.
11 | % - includes (cell array): Optional array of include directories.
12 | % - directory (string): Optional path of target directory.
13 | %
14 | % Output:
15 | % - success (boolean): True if successful.
16 | %
17 |
18 | function datenum = file_timestamp(filename)
19 | if ~exist(filename, 'file')
20 | datenum = 0;
21 | return;
22 | end;
23 | file_description = dir(filename);
24 | datenum = file_description.datenum;
25 | end
26 |
27 | mexname = fullfile(directory, sprintf('%s.%s', name, mexext));
28 |
29 | if exist(mexname, 'file') == 2 || exist(mexname, 'file') == 3
30 |
31 | function_timestamp = file_timestamp(mexname);
32 |
33 | older = cellfun(@(x) file_timestamp(x) < function_timestamp, files, 'UniformOutput', true);
34 |
35 | if all(older)
36 | success = true;
37 | return;
38 | end;
39 | end
40 |
41 | arguments = {};
42 |
43 | if is_octave()
44 | arguments{end+1} = '-DOCTAVE';
45 | else
46 | arguments{end+1} = '-lut';
47 | end
48 |
49 | if nargin < 3
50 | includes = cell(0);
51 | end
52 |
53 | if nargin < 4
54 | directory = '';
55 | end;
56 |
57 | includes = cellfun(@(x) sprintf('-I%s', x), includes, 'UniformOutput', false);
58 |
59 | old_dir = pwd;
60 |
61 | try
62 |
63 | if ~isempty(directory)
64 | cd(directory)
65 | end;
66 |
67 | if is_octave()
68 |
69 | [out, status] = mkoctfile('-mex', '-o', name, varargin{:}, includes{:}, files{:}, arguments{:});
70 |
71 | % Clean up mess
72 | for i = 1:numel(files)
73 | [pathstr, name, ext] = fileparts(files{i});
74 | tmpfile = fullfile(directory, [name, '.o']);
75 | if exist(tmpfile, 'file')
76 | delete(tmpfile);
77 | end
78 | end
79 |
80 | if status
81 | error('Compile problem, see compiler output.');
82 | end;
83 |
84 | else
85 |
86 | mex('-output', name, varargin{:}, includes{:}, files{:}, arguments{:});
87 |
88 | end
89 |
90 | cd(old_dir);
91 |
92 | success = true;
93 |
94 | catch e
95 | cd(old_dir);
96 | print_text('ERROR: Unable to compile MEX function: "%s".', e.message);
97 | success = false;
98 |
99 | end
100 |
101 | end
102 |
--------------------------------------------------------------------------------
/vot-toolkit-master/sequence/read_trajectory.cpp:
--------------------------------------------------------------------------------
1 |
2 |
3 | #include
4 | #include
5 | #include
6 | #include
7 |
8 | #include "mex.h"
9 | #include "region.h"
10 |
11 | using namespace std;
12 |
13 | char* getString(const mxArray *arg) {
14 |
15 | if (mxGetM(arg) != 1)
16 | mexErrMsgTxt("Must be a string");
17 |
18 | int l = (int) mxGetN(arg);
19 |
20 | char* str = (char *) malloc(sizeof(char) * (l + 1));
21 |
22 | mxGetString(arg, str, (l + 1));
23 |
24 | return str;
25 | }
26 |
27 | void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
28 |
29 | if( nrhs != 1 ) mexErrMsgTxt("Exactly one string input argument required.");
30 | if( nlhs != 1 ) mexErrMsgTxt("Exactly one output argument required.");
31 |
32 | char* path = getString(prhs[0]);
33 |
34 | std::ifstream ifs;
35 | ifs.open (path, std::ifstream::in);
36 |
37 | vector regions;
38 |
39 | if (ifs.is_open()) {
40 |
41 | int line_size = sizeof(char) * 2048;
42 | char* line_buffer = (char*) malloc(line_size);
43 | int line = 0;
44 |
45 | while (ifs.good()) {
46 |
47 | line++;
48 |
49 | ifs.getline(line_buffer, line_size);
50 |
51 | if (!ifs.good()) break;
52 |
53 | region_container* region = NULL;
54 |
55 | if (region_parse(line_buffer, ®ion)) {
56 |
57 | regions.push_back(region);
58 |
59 | } else {
60 |
61 | char message[500];
62 | sprintf(message, "Unable to parse region at line %d, skipping.", line);
63 | mexWarnMsgTxt(message);
64 |
65 | }
66 |
67 | }
68 |
69 | free(line_buffer);
70 |
71 | plhs[0] = mxCreateCellMatrix((int)regions.size(), 1);
72 |
73 | for (int i = 0; i < regions.size(); i++) {
74 |
75 | mxArray* val = NULL;
76 | region_container* region = regions[i];
77 |
78 | switch (region->type) {
79 | case RECTANGLE: {
80 | val = mxCreateDoubleMatrix(1, 4, mxREAL);
81 | double *p = (double*) mxGetPr(val);
82 | p[0] = region->data.rectangle.x;
83 | p[1] = region->data.rectangle.y;
84 | p[2] = region->data.rectangle.width;
85 | p[3] = region->data.rectangle.height;
86 | break;
87 | }
88 | case POLYGON: {
89 | val = mxCreateDoubleMatrix(1, region->data.polygon.count * 2, mxREAL);
90 | double *p = (double*) mxGetPr(val);
91 |
92 | for (int i = 0; i < region->data.polygon.count; i++) {
93 | p[i*2] = region->data.polygon.x[i];
94 | p[i*2+1] = region->data.polygon.y[i];
95 | }
96 |
97 | break;
98 | }
99 | case SPECIAL: {
100 | val = mxCreateDoubleMatrix(1, 1, mxREAL);
101 | double *p = (double*) mxGetPr(val);
102 | p[0] = region->data.special;
103 | break;
104 | }
105 | }
106 |
107 | if (val) mxSetCell(plhs[0], i, val);
108 |
109 | region_release(®ion);
110 |
111 | }
112 |
113 | } else {
114 | free(path);
115 | mexErrMsgTxt("Unable to open file for reading.");
116 | }
117 |
118 | ifs.close();
119 | free(path);
120 | }
121 |
122 |
123 |
--------------------------------------------------------------------------------
/vot-toolkit-master/sequence/region_mask.cpp:
--------------------------------------------------------------------------------
1 |
2 | #include
3 | #include
4 |
5 | #include "mex.h"
6 | #include "region.h"
7 |
8 | #define MEX_TEST_DOUBLE(I) (mxGetClassID(prhs[I]) == mxDOUBLE_CLASS)
9 | #define MEX_TEST_VECTOR(I) (mxGetNumberOfDimensions(prhs[I]) == 2 && mxGetM(prhs[I]) == 1)
10 |
11 | #if defined(__OS2__) || defined(__WINDOWS__) || defined(WIN32) || defined(WIN64) || defined(_MSC_VER)
12 | #define strcmpi _strcmpi
13 | #else
14 | #define strcmpi strcasecmp
15 | #endif
16 |
17 | region_container* get_polygon(const mxArray * input) {
18 |
19 | region_container* p = NULL;
20 | double *r = (double*)mxGetPr(input);
21 | int l = mxGetN(input);
22 |
23 | if (l % 2 == 0 && l > 6) {
24 |
25 | p = region_create_polygon(l / 2);
26 |
27 | for (int i = 0; i < p->data.polygon.count; i++) {
28 | p->data.polygon.x[i] = r[i*2];
29 | p->data.polygon.y[i] = r[i*2+1];
30 | }
31 |
32 | } else if (l == 4) {
33 |
34 | region_container* t = NULL;
35 |
36 | t = region_create_rectangle(r[0], r[1], r[2], r[3]);
37 |
38 | p = region_convert(t, POLYGON);
39 |
40 | region_release(&t);
41 |
42 | }
43 |
44 | return p;
45 |
46 | }
47 |
48 | int getSingleInteger(const mxArray *arg) {
49 |
50 | if (mxGetM(arg) != 1 || mxGetN(arg) != 1)
51 | mexErrMsgTxt("Parameter must be a single value");
52 |
53 | if (mxIsInt32(arg))
54 | return ((int*)mxGetPr(arg))[0];
55 |
56 | if (mxIsDouble(arg))
57 | return (int) ((double*)mxGetPr(arg))[0];
58 |
59 | return 0;
60 | }
61 |
62 | char* get_string(const mxArray *arg) {
63 |
64 | if (mxGetM(arg) != 1)
65 | mexErrMsgTxt("Must be an array of chars");
66 |
67 | int l = (int) mxGetN(arg);
68 |
69 | char* cstr = (char *) malloc(sizeof(char) * (l + 1));
70 |
71 | mxGetString(arg, cstr, (l + 1));
72 |
73 | return cstr;
74 | }
75 |
76 | void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
77 |
78 | region_container* p = NULL;
79 |
80 | if( nrhs < 3 ) mexErrMsgTxt("One vector and two integer arguments required.");
81 | if( nlhs != 1 ) mexErrMsgTxt("Exactly one output argument required.");
82 |
83 | if (!MEX_TEST_VECTOR(0) || !MEX_TEST_DOUBLE(0)) mexErrMsgTxt("First argument must be a vector of type double");
84 |
85 | region_clear_flags(REGION_LEGACY_RASTERIZATION);
86 | if (nrhs > 3) {
87 | char* codestr = get_string(prhs[3]);
88 | if (strcmpi(codestr, "legacy") == 0)
89 | region_set_flags(REGION_LEGACY_RASTERIZATION);
90 | free(codestr);
91 | }
92 |
93 | int width = getSingleInteger(prhs[1]);
94 | int height = getSingleInteger(prhs[2]);
95 |
96 | p = get_polygon(prhs[0]);
97 | float* tmp = p->data.polygon.x; p->data.polygon.x = p->data.polygon.y; p->data.polygon.y = tmp;
98 |
99 | plhs[0] = mxCreateLogicalMatrix(height, width);
100 | char *result = (char*) mxGetData(plhs[0]);
101 |
102 | region_get_mask(p, result, width, height);
103 |
104 | if (p) region_release(&p);
105 |
106 | }
107 |
108 |
--------------------------------------------------------------------------------
/vot-toolkit-master/utilities/relativepath.m:
--------------------------------------------------------------------------------
1 | function relative_path = relativepath( target_path, root_path )
2 | % relativepath Returns the relative path from an root path to the target path
3 | %
4 | % Returns the relative path from an root path to the target path.
5 | % Both arguments must be strings with absolute paths.
6 | % The actual path is optional, if omitted the current dir is used instead.
7 | % In case the volume drive letters don't match, an absolute path will be returned.
8 | % If a relative path is returned, it always starts with '.\' or '..\'
9 | %
10 | % Credit: Jochen Lenz
11 | %
12 | % Input:
13 | % - target_path (string): Absolute path.
14 | % - root_path (string, optional): Start for relative path. Defaults to current directory.
15 | %
16 | % Output:
17 | % - relative_path (string): Relative path.
18 | %
19 |
20 |
21 | % 2nd parameter is optional:
22 | if nargin < 2
23 | root_path = cd;
24 | end
25 |
26 | % Predefine return string:
27 | relative_path = '';
28 |
29 | % Make sure strings end by a filesep character:
30 | if isempty(root_path) || ~isequal(root_path(end),filesep)
31 | root_path = [root_path filesep];
32 | end
33 | if isempty(target_path) || ~isequal(target_path(end),filesep)
34 | target_path = [target_path filesep];
35 | end
36 |
37 | if isunix()
38 | [root_path] = fileparts(root_path);
39 | [target_path] = fileparts(target_path);
40 | else
41 | % Convert to all lowercase:
42 | [root_path] = fileparts(lower(root_path));
43 | [target_path] = fileparts(lower(target_path));
44 | end;
45 |
46 | % Create a cell-array containing the directory levels:
47 | act_path_cell = pathparts(root_path);
48 | tgt_path_cell = pathparts(target_path);
49 |
50 | % If volumes are different, return absolute path:
51 | if isempty(act_path_cell) || isempty(tgt_path_cell)
52 | return % rel_path = ''
53 | else
54 | if ~isequal( act_path_cell{1} , tgt_path_cell{1} )
55 | relative_path = target_path;
56 | return
57 | end
58 | end
59 |
60 | % Remove level by level, as long as both are equal:
61 | while ~isempty(act_path_cell) > 0 && ~isempty(tgt_path_cell)
62 | if isequal( act_path_cell{1}, tgt_path_cell{1} )
63 | act_path_cell(1) = [];
64 | tgt_path_cell(1) = [];
65 | else
66 | break
67 | end
68 | end
69 |
70 | % As much levels down ('..\') as levels are remaining in "act_path":
71 | for i = 1 : length(act_path_cell)
72 | relative_path = fullfile('..', relative_path);
73 | end
74 |
75 | % Relative directory levels to target directory:
76 | for i = 1 : length(tgt_path_cell)
77 | relative_path = fullfile(relative_path, tgt_path_cell{i});
78 | end
79 |
80 | % Start with '.' or '..' :
81 | if isempty(relative_path)
82 | relative_path = ['.', filesep];
83 | elseif ~isequal(relative_path(1),'.')
84 | relative_path = fullfile('.', relative_path);
85 | end
86 |
87 | return
88 |
89 | % -------------------------------------------------
90 |
91 | function path_cell = pathparts(path_str)
92 |
93 | path_str = [filesep path_str filesep];
94 | path_cell = {};
95 |
96 | sep_pos = findstr( path_str, filesep );
97 | for i = 1 : length(sep_pos)-1
98 | path_cell{i} = path_str( sep_pos(i)+1 : sep_pos(i+1)-1 );
99 | end
100 |
101 | return
102 |
--------------------------------------------------------------------------------
/vot-toolkit-master/report/generate_ranking_plot.m:
--------------------------------------------------------------------------------
1 | function handle = generate_ranking_plot(trackers, accuracy, robustness, varargin)
2 | % generate_ar_plot Generate an A-R ranking plot
3 | %
4 | % The function generates an A-R ranking plot for a sequence of measurements.
5 | %
6 | % Input:
7 | % - trackers (cell): A cell array of tracker structures.
8 | % - accuracy (matrix): Accuracy ranks.
9 | % - robustness (matrix): Robustness ranks.
10 | % - varargin[Title] (string): A title of the plot.
11 | % - varargin[Limit] (double): A manually set maximum rank.
12 | % - varargin[Visible] (boolean): Is the figure visible on the display.
13 | % - varargin[Width] (double): Figure width hint.
14 | % - varargin[Height] (double): Figure height hint.
15 | % - varargin[Handle] (handle): Plot on existing figure handle.
16 | % - varargin[Legend] (boolean): Render plot legend.
17 | %
18 | % Output:
19 | % - handle (handle): A figure handle.
20 | %
21 |
22 | plot_title = [];
23 | visible = false;
24 | plot_limit = numel(trackers);
25 | width = [];
26 | height = [];
27 |
28 | handle = [];
29 |
30 | show_legend = true;
31 |
32 | for i = 1:2:length(varargin)
33 | switch lower(varargin{i})
34 | case 'title'
35 | plot_title = varargin{i+1};
36 | case 'limit'
37 | plot_limit = varargin{i+1};
38 | case 'visible'
39 | visible = varargin{i+1};
40 | case 'width'
41 | width = varargin{i+1};
42 | case 'height'
43 | height = varargin{i+1};
44 | case 'handle'
45 | handle = varargin{i+1};
46 | case 'legend'
47 | show_legend = varargin{i+1};
48 | otherwise
49 | error(['Unknown switch ', varargin{i},'!']) ;
50 | end
51 | end
52 |
53 | if isempty(handle)
54 | if ~visible
55 | handle = figure('Visible', 'off');
56 | else
57 | handle = figure();
58 | end
59 | else
60 | figure(handle);
61 | end;
62 |
63 | if isempty(width)
64 | width = iff(show_legend, 6, 4);
65 | end
66 |
67 | if isempty(height)
68 | height = 4;
69 | end
70 |
71 | hold on; box on; grid on;
72 | title(plot_title, 'interpreter','none');
73 |
74 | available = true(length(trackers), 1);
75 |
76 | for t = 1:length(trackers)
77 |
78 | if isnan(accuracy(t))
79 | available(t) = 0;
80 | continue;
81 | end;
82 |
83 | plot(robustness(t), accuracy(t), trackers{t}.style.symbol, 'Color', ...
84 | trackers{t}.style.color, 'MarkerSize', 10, 'LineWidth', trackers{t}.style.width);
85 |
86 | end;
87 | plot_labels = cellfun(@(tracker) tracker.label, trackers, 'UniformOutput', 0);
88 | if show_legend
89 | legend(plot_labels(available), 'Location', 'NorthWestOutside', 'interpreter', 'none', 'FontSize', 9);
90 | end;
91 | xlabel('Robustness rank'); set(gca, 'XDir', 'Reverse');
92 | ylabel('Accuracy rank'); set(gca, 'YDir', 'Reverse');
93 | xlim([0.9, plot_limit + 0.1]);
94 | ylim([0.9, plot_limit + 0.1]);
95 |
96 | set(handle, 'PaperUnits', 'inches', 'PaperSize', [width, height], 'PaperPosition', [0, 0, width, height]);
97 |
98 | hold off;
99 |
--------------------------------------------------------------------------------
/vot-toolkit-master/index.md:
--------------------------------------------------------------------------------
1 | VOT toolkit documentation
2 | =========================
3 |
4 | This is the official documentation for the [Visual Object Tracking (VOT) challenge](http://votchallenge.net/) toolkit. The toolkit is a set of
5 | Matlab (Octave compatible) scripts that estimate the performance of visual object trackers.
6 |
7 | The official code repository is available on [Github](https://github.com/vicoslab/vot-toolkit/). You can also
8 | subscribe to the VOT [mailing list](https://service.ait.ac.at/mailman/listinfo/votchallenge) to receive news about challenges and important software updates.
9 |
10 | Platform support
11 | ----------------
12 |
13 | The toolkit is written in Matlab language with a strong emphasis on Octave compatibility as well as support for multiple versions of Matlab (at the moment it was tested with versions from 2011 to 2015).
14 |
15 | The code should work on Windows, Linux and OSX, however, it is hard to verify this on all versions and system configurations. If you therefore find that there are some issues on your computer setup, submit a bug report at [Github](https://github.com/vicoslab/vot-toolkit/issues/new) as soon as possible.
16 |
17 | Inquiries, Question and Comments
18 | --------------------------------
19 |
20 | If you have any further inquiries, question, or comments, please use the official [support forum](https://groups.google.com/forum/?hl=en#!forum/votchallenge-help). If you would like to file a bug report or a feature request, use the [Github issue tracker](https://github.com/vicoslab/vot-toolkit/issues).
21 |
22 | Terminology
23 | -----------
24 |
25 | For better understanding, here are some definitions of important terms that are used in the documentation:
26 |
27 | * _Workspace_ - An directory that contains results for a single stack of experiments and your working scripts. It should not be the same directory that also contains the toolkit.
28 | * _Tracker_ - An executable or a script containing a tracking algorithm that is evaluated.
29 | * _Sequence_ - A single sequence of images with manually annotated ground-truth positions of the object used for evaluation.
30 | * _Annotation_ - Manual or automatic description of visual position of the object.
31 | * _Trajectory_ - A sequence of annotations that describes the motion of the object in the sequence. In the toolkit it is saved to a file in a text format.
32 | * _Tracker run_ - A single execution of a tracker on an entire sequence or its subset.
33 | * _Trial_ - If a tracker fails during tracking it is reinitialized after the first point of failure.
34 | * _Repetition_ - To properly address the potential stochastic nature of the algorithm, several trials are performed on each sequence.
35 | * _Experiment_ - Evaluation of a tracker on a set of sequences in specific conditions. Specific experiment may change the original sequences to simulate some specific kind of circumstances (e.g. image noise, initialization error).
36 | * _Evaluation_ - Performing a set of experiments on a specific tracker.
37 | * _Region overlap_ - Overlap distance between two regions.
38 |
39 | Modules
40 | -------
41 |
42 | The toolkit contains of several interdependent modules:
43 |
44 | - [Workspace](workspace/index.md)
45 | - [Tracker](tracker/index.md)
46 | - [Sequence](sequence/index.md)
47 | - [Analysis](analysis/index.md)
48 | - [Report](report/index.md)
49 | - [Utilities](utilities/index.md)
50 |
51 |
--------------------------------------------------------------------------------
/vot-toolkit-master/experiment/experiment_unsupervised.m:
--------------------------------------------------------------------------------
1 | function [files, metadata] = experiment_unsupervised(tracker, sequence, directory, parameters, scan)
2 |
3 | files = {};
4 | metadata.completed = true;
5 | cache = get_global_variable('experiment_cache', true);
6 | silent = get_global_variable('experiment_silent', false);
7 |
8 | defaults = struct('repetitions', 15);
9 | context = struct_merge(parameters, defaults);
10 | metadata.deterministic = false;
11 |
12 | time_file = fullfile(directory, sprintf('%s_time.txt', sequence.name));
13 |
14 | times = zeros(sequence.length, context.repetitions);
15 |
16 | if ~scan && cache && exist(time_file, 'file')
17 | times = csvread(time_file);
18 | end;
19 |
20 | r = context.repetitions;
21 |
22 | if isfield(tracker, 'metadata') && isfield(tracker.metadata, 'deterministic') && tracker.metadata.deterministic
23 | r = 1;
24 | end
25 |
26 | check_deterministic = ~(scan && nargout < 2); % Ensure faster execution when we only want a list of files by ommiting determinisim check.
27 |
28 | for i = 1:r
29 |
30 | result_file = fullfile(directory, sprintf('%s_%03d.txt', sequence.name, i));
31 |
32 | if cache && exist(result_file, 'file')
33 | files{end+1} = result_file; %#ok
34 | continue;
35 | end;
36 |
37 | if check_deterministic && i == 4 && is_deterministic(sequence, 3, directory)
38 | if ~silent
39 | print_debug('Detected a deterministic tracker, skipping remaining trials.');
40 | end;
41 | metadata.deterministic = true;
42 | break;
43 | end;
44 |
45 | if scan
46 | metadata.completed = false;
47 | continue;
48 | end;
49 |
50 | print_indent(1);
51 |
52 | print_text('Repetition %d', i);
53 |
54 | context.repetition = i;
55 |
56 | data.sequence = sequence;
57 | data.index = 1;
58 | data.context = context;
59 | data.result = repmat({0}, sequence.length, 1);
60 | data.timing = nan(sequence.length, 1);
61 |
62 | data = tracker_run(tracker, @callback, data);
63 |
64 | times(:, i) = data.timing;
65 | write_trajectory(result_file, data.result);
66 | csvwrite(time_file, times);
67 |
68 | print_indent(-1);
69 | end;
70 |
71 | if exist(time_file, 'file')
72 | files{end+1} = time_file;
73 | else
74 | metadata.completed = false;
75 | end;
76 |
77 | end
78 |
79 | function [image, region, properties, data] = callback(state, data)
80 |
81 | region = [];
82 | image = [];
83 | properties = struct();
84 |
85 | % Handle initial frame (initialize for the first time)
86 | if isempty(state.region)
87 | region = data.sequence.initialize(data.sequence, data.index, data.context);
88 | image = get_image(data.sequence, data.index);
89 | return;
90 | end;
91 |
92 | % Store initialization
93 | if data.index == 1
94 | data.result{data.index} = 1;
95 | else
96 | data.result{data.index} = state.region;
97 | end;
98 | data.timing(data.index) = state.time;
99 |
100 | data.index = data.index + 1;
101 |
102 | % End of sequence
103 | if data.index > data.sequence.length
104 | return;
105 | end
106 |
107 | image = get_image(data.sequence, data.index);
108 |
109 | end
110 |
111 |
--------------------------------------------------------------------------------
/vot-toolkit-master/vot-workspace/tracker/kcf/fhog.m:
--------------------------------------------------------------------------------
1 | function H = fhog( I, binSize, nOrients, clip, crop )
2 | % Efficiently compute Felzenszwalb's HOG (FHOG) features.
3 | %
4 | % A fast implementation of the HOG variant used by Felzenszwalb et al.
5 | % in their work on discriminatively trained deformable part models.
6 | % http://www.cs.berkeley.edu/~rbg/latent/index.html
7 | % Gives nearly identical results to features.cc in code release version 5
8 | % but runs 4x faster (over 125 fps on VGA color images).
9 | %
10 | % The computed HOG features are 3*nOrients+5 dimensional. There are
11 | % 2*nOrients contrast sensitive orientation channels, nOrients contrast
12 | % insensitive orientation channels, 4 texture channels and 1 all zeros
13 | % channel (used as a 'truncation' feature). Using the standard value of
14 | % nOrients=9 gives a 32 dimensional feature vector at each cell. This
15 | % variant of HOG, refered to as FHOG, has been shown to achieve superior
16 | % performance to the original HOG features. For details please refer to
17 | % work by Felzenszwalb et al. (see link above).
18 | %
19 | % This function is essentially a wrapper for calls to gradientMag()
20 | % and gradientHist(). Specifically, it is equivalent to the following:
21 | % [M,O] = gradientMag( I,0,0,0,1 ); softBin = -1; useHog = 2;
22 | % H = gradientHist(M,O,binSize,nOrients,softBin,useHog,clip);
23 | % See gradientHist() for more general usage.
24 | %
25 | % This code requires SSE2 to compile and run (most modern Intel and AMD
26 | % processors support SSE2). Please see: http://en.wikipedia.org/wiki/SSE2.
27 | %
28 | % USAGE
29 | % H = fhog( I, [binSize], [nOrients], [clip], [crop] )
30 | %
31 | % INPUTS
32 | % I - [hxw] color or grayscale input image (must have type single)
33 | % binSize - [8] spatial bin size
34 | % nOrients - [9] number of orientation bins
35 | % clip - [.2] value at which to clip histogram bins
36 | % crop - [0] if true crop boundaries
37 | %
38 | % OUTPUTS
39 | % H - [h/binSize w/binSize nOrients*3+5] computed hog features
40 | %
41 | % EXAMPLE
42 | % I=imResample(single(imread('peppers.png'))/255,[480 640]);
43 | % tic, for i=1:100, H=fhog(I,8,9); end; disp(100/toc) % >125 fps
44 | % figure(1); im(I); V=hogDraw(H,25,1); figure(2); im(V)
45 | %
46 | % EXAMPLE
47 | % % comparison to features.cc (requires DPM code release version 5)
48 | % I=imResample(single(imread('peppers.png'))/255,[480 640]); Id=double(I);
49 | % tic, for i=1:100, H1=features(Id,8); end; disp(100/toc)
50 | % tic, for i=1:100, H2=fhog(I,8,9,.2,1); end; disp(100/toc)
51 | % figure(1); montage2(H1); figure(2); montage2(H2);
52 | % D=abs(H1-H2); mean(D(:))
53 | %
54 | % See also hog, hogDraw, gradientHist
55 | %
56 | % Piotr's Image&Video Toolbox Version 3.23
57 | % Copyright 2013 Piotr Dollar. [pdollar-at-caltech.edu]
58 | % Please email me if you find bugs, or have suggestions or questions!
59 | % Licensed under the Simplified BSD License [see external/bsd.txt]
60 |
61 | %Note: modified to be more self-contained
62 |
63 | if( nargin<2 ), binSize=8; end
64 | if( nargin<3 ), nOrients=9; end
65 | if( nargin<4 ), clip=.2; end
66 | if( nargin<5 ), crop=0; end
67 |
68 | softBin = -1; useHog = 2; b = binSize;
69 |
70 | [M,O]=gradientMex('gradientMag',I,0,1);
71 |
72 | H = gradientMex('gradientHist',M,O,binSize,nOrients,softBin,useHog,clip);
73 |
74 | if( crop ), e=mod(size(I),b) 0.2
82 |
83 | description = 'Below average';
84 | css = 'bad';
85 |
86 | elseif value < -0.2
87 |
88 | description = 'Above average';
89 | css = 'good';
90 |
91 | else
92 | description = 'Average';
93 | css = 'average';
94 | end
95 |
96 | description = sprintf('%s (%d of %d)', description, find(O == selection, 1), length(O));
97 |
98 | end
99 |
100 |
--------------------------------------------------------------------------------