"examples/vscode:/vscode.git/clone" did not exist on "aff6b685c39b333277220e2e3a8574d5076931f8"
main.cpp 43.7 KB
Newer Older
1

2
#include "dlib/data_io.h"
3
#include "dlib/string.h"
4
#include "metadata_editor.h"
Davis King's avatar
Davis King committed
5
#include "convert_pascal_xml.h"
6
#include "convert_pascal_v1.h"
7
#include "convert_idl.h"
8
#include "cluster.h"
Davis King's avatar
Davis King committed
9
#include <dlib/cmd_line_parser.h>
Davis King's avatar
Davis King committed
10
#include <dlib/image_transforms.h>
11
#include <dlib/svm.h>
12
#include <dlib/console_progress_indicator.h>
Davis King's avatar
Davis King committed
13
#include <dlib/md5.h>
14

15
16
#include <iostream>
#include <fstream>
17
#include <string>
18
#include <set>
19

20
#include <dlib/dir_nav.h>
21
22


23
const char* VERSION = "1.7";
Davis King's avatar
Davis King committed
24

25
const int JPEG_QUALITY = 90;
Davis King's avatar
Davis King committed
26

27
28
29
30

using namespace std;
using namespace dlib;

31
32
// ----------------------------------------------------------------------------------------

Davis King's avatar
Davis King committed
33
void create_new_dataset (
Davis King's avatar
Davis King committed
34
    const command_line_parser& parser
Davis King's avatar
Davis King committed
35
36
37
38
39
40
41
42
)
{
    using namespace dlib::image_dataset_metadata;

    const std::string filename = parser.option("c").argument();
    // make sure the file exists so we can use the get_parent_directory() command to
    // figure out it's parent directory.
    make_empty_file(filename);
Davis King's avatar
Davis King committed
43
    const std::string parent_dir = get_parent_directory(file(filename));
Davis King's avatar
Davis King committed
44
45
46
47
48
49
50
51
52
53
54
55

    unsigned long depth = 0;
    if (parser.option("r"))
        depth = 30;

    dataset meta;
    meta.name = "imglab dataset";
    meta.comment = "Created by imglab tool.";
    for (unsigned long i = 0; i < parser.number_of_arguments(); ++i)
    {
        try
        {
Davis King's avatar
Davis King committed
56
            const string temp = strip_path(file(parser[i]), parent_dir);
Davis King's avatar
Davis King committed
57
58
59
60
61
62
63
            meta.images.push_back(image(temp));
        }
        catch (dlib::file::file_not_found&)
        {
            // then parser[i] should be a directory

            std::vector<file> files = get_files_in_directory_tree(parser[i], 
64
                                                                  match_endings(".png .PNG .jpeg .JPEG .jpg .JPG .bmp .BMP .dng .DNG .gif .GIF"),
Davis King's avatar
Davis King committed
65
66
67
68
69
                                                                  depth);
            sort(files.begin(), files.end());

            for (unsigned long j = 0; j < files.size(); ++j)
            {
Davis King's avatar
Davis King committed
70
                meta.images.push_back(image(strip_path(files[j], parent_dir)));
Davis King's avatar
Davis King committed
71
72
73
74
75
76
77
78
            }
        }
    }

    save_image_dataset_metadata(meta, filename);
}

// ----------------------------------------------------------------------------------------
79

80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
int split_dataset (
    const command_line_parser& parser
)
{
    if (parser.number_of_arguments() != 1)
    {
        cerr << "The --split option requires you to give one XML file on the command line." << endl;
        return EXIT_FAILURE;
    }

    const std::string label = parser.option("split").argument();

    dlib::image_dataset_metadata::dataset data, data_with, data_without;
    load_image_dataset_metadata(data, parser[0]);

    data_with.name = data.name;
    data_with.comment = data.comment;
    data_without.name = data.name;
    data_without.comment = data.comment;

    for (unsigned long i = 0; i < data.images.size(); ++i)
    {
102
        auto&& temp = data.images[i];
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

        bool has_the_label = false;
        // check for the label we are looking for
        for (unsigned long j = 0; j < temp.boxes.size(); ++j)
        {
            if (temp.boxes[j].label == label)
            {
                has_the_label = true;
                break;
            }
        }

        if (has_the_label)
            data_with.images.push_back(temp);
        else
            data_without.images.push_back(temp);
    }


    save_image_dataset_metadata(data_with, left_substr(parser[0],".") + "_with_"+label + ".xml");
    save_image_dataset_metadata(data_without, left_substr(parser[0],".") + "_without_"+label + ".xml");

    return EXIT_SUCCESS;
}

// ----------------------------------------------------------------------------------------

130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
void print_all_labels (
    const dlib::image_dataset_metadata::dataset& data
)
{
    std::set<std::string> labels;
    for (unsigned long i = 0; i < data.images.size(); ++i)
    {
        for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
        {
            labels.insert(data.images[i].boxes[j].label);
        }
    }

    for (std::set<std::string>::iterator i = labels.begin(); i != labels.end(); ++i)
    {
        if (i->size() != 0)
        {
            cout << *i << endl;
        }
    }
}

// ----------------------------------------------------------------------------------------

154
155
156
157
158
void print_all_label_stats (
    const dlib::image_dataset_metadata::dataset& data
)
{
    std::map<std::string, running_stats<double> > area_stats, aspect_ratio;
159
    std::map<std::string, int> image_hits;
160
    std::set<std::string> labels;
161
    unsigned long num_unignored_boxes = 0;
162
163
    for (unsigned long i = 0; i < data.images.size(); ++i)
    {
164
        std::set<std::string> temp;
165
166
167
        for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
        {
            labels.insert(data.images[i].boxes[j].label);
168
            temp.insert(data.images[i].boxes[j].label);
169
170
171
172

            area_stats[data.images[i].boxes[j].label].add(data.images[i].boxes[j].rect.area());
            aspect_ratio[data.images[i].boxes[j].label].add(data.images[i].boxes[j].rect.width()/
                                                    (double)data.images[i].boxes[j].rect.height());
173
174
175

            if (!data.images[i].boxes[j].ignore)
                ++num_unignored_boxes;
176
        }
177
178
179
180

        // count the number of images for each label
        for (std::set<std::string>::iterator i = temp.begin(); i != temp.end(); ++i)
            image_hits[*i] += 1;
181
182
    }

183
    cout << "Number of images: "<< data.images.size() << endl;
184
185
    cout << "Number of different labels: "<< labels.size() << endl;
    cout << "Number of non-ignored boxes: " << num_unignored_boxes << endl << endl;
186
187
188

    for (std::set<std::string>::iterator i = labels.begin(); i != labels.end(); ++i)
    {
189
190
191
        if (i->size() == 0)
            cout << "Unlabeled Boxes:" << endl;
        else
192
            cout << "Label: "<< *i << endl;
193
194
195
196
197
198
199
200
201
        cout << "   number of images:      " << image_hits[*i] << endl;
        cout << "   number of occurrences: " << area_stats[*i].current_n() << endl;
        cout << "   min box area:    " << area_stats[*i].min() << endl;
        cout << "   max box area:    " << area_stats[*i].max() << endl;
        cout << "   mean box area:   " << area_stats[*i].mean() << endl;
        cout << "   stddev box area: " << area_stats[*i].stddev() << endl;
        cout << "   mean width/height ratio:   " << aspect_ratio[*i].mean() << endl;
        cout << "   stddev width/height ratio: " << aspect_ratio[*i].stddev() << endl;
        cout << endl;
202
203
204
205
206
    }
}

// ----------------------------------------------------------------------------------------

Davis King's avatar
Davis King committed
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
void rename_labels (
    dlib::image_dataset_metadata::dataset& data,
    const std::string& from,
    const std::string& to
)
{
    for (unsigned long i = 0; i < data.images.size(); ++i)
    {
        for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
        {
            if (data.images[i].boxes[j].label == from)
                data.images[i].boxes[j].label = to;
        }
    }

}

// ----------------------------------------------------------------------------------------

226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
void ignore_labels (
    dlib::image_dataset_metadata::dataset& data,
    const std::string& label
)
{
    for (unsigned long i = 0; i < data.images.size(); ++i)
    {
        for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
        {
            if (data.images[i].boxes[j].label == label)
                data.images[i].boxes[j].ignore = true;
        }
    }
}

// ----------------------------------------------------------------------------------------

243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
void merge_metadata_files (
    const command_line_parser& parser
)
{
    image_dataset_metadata::dataset src, dest;
    load_image_dataset_metadata(src, parser.option("add").argument(0));
    load_image_dataset_metadata(dest, parser.option("add").argument(1));

    std::map<string,image_dataset_metadata::image> merged_data;
    for (unsigned long i = 0; i < dest.images.size(); ++i)
        merged_data[dest.images[i].filename] = dest.images[i];
    // now add in the src data and overwrite anything if there are duplicate entries.
    for (unsigned long i = 0; i < src.images.size(); ++i)
        merged_data[src.images[i].filename] = src.images[i];

    // copy merged data into dest
    dest.images.clear();
    for (std::map<string,image_dataset_metadata::image>::const_iterator i = merged_data.begin(); 
        i != merged_data.end(); ++i)
    {
        dest.images.push_back(i->second);
    }

    save_image_dataset_metadata(dest, "merged.xml");
}

// ----------------------------------------------------------------------------------------

Davis King's avatar
Davis King committed
271
272
273
274
275
276
277
278
string to_png_name (const string& filename)
{
    string::size_type pos = filename.find_last_of(".");
    if (pos == string::npos)
        throw dlib::error("invalid filename: " + filename);
    return filename.substr(0,pos) + ".png";
}

279
280
281
282
283
284
285
286
string to_jpg_name (const string& filename)
{
    string::size_type pos = filename.find_last_of(".");
    if (pos == string::npos)
        throw dlib::error("invalid filename: " + filename);
    return filename.substr(0,pos) + ".jpg";
}

Davis King's avatar
Davis King committed
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
// ----------------------------------------------------------------------------------------

void flip_dataset(const command_line_parser& parser)
{
    image_dataset_metadata::dataset metadata;
    const string datasource = parser.option("flip").argument();
    load_image_dataset_metadata(metadata,datasource);

    // Set the current directory to be the one that contains the
    // metadata file. We do this because the file might contain
    // file paths which are relative to this folder.
    set_current_dir(get_parent_directory(file(datasource)));

    const string metadata_filename = get_parent_directory(file(datasource)).full_name() +
        directory::get_separator() + "flipped_" + file(datasource).name();


    array2d<rgb_pixel> img, temp;
    for (unsigned long i = 0; i < metadata.images.size(); ++i)
    {
        file f(metadata.images[i].filename);
308
        string filename = get_parent_directory(f).full_name() + directory::get_separator() + "flipped_" + to_png_name(f.name());
Davis King's avatar
Davis King committed
309
310
311

        load_image(img, metadata.images[i].filename);
        flip_image_left_right(img, temp);
312
313
314
315
316
317
318
319
320
        if (parser.option("jpg"))
        {
            filename = to_jpg_name(filename);
            save_jpeg(temp, filename,JPEG_QUALITY);
        }
        else
        {
            save_png(temp, filename);
        }
Davis King's avatar
Davis King committed
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339

        for (unsigned long j = 0; j < metadata.images[i].boxes.size(); ++j)
        {
            metadata.images[i].boxes[j].rect = impl::flip_rect_left_right(metadata.images[i].boxes[j].rect, get_rect(img));

            // flip all the object parts
            std::map<std::string,point>::iterator k;
            for (k = metadata.images[i].boxes[j].parts.begin(); k != metadata.images[i].boxes[j].parts.end(); ++k)
            {
                k->second = impl::flip_rect_left_right(rectangle(k->second,k->second), get_rect(img)).tl_corner();
            }
        }

        metadata.images[i].filename = filename;
    }

    save_image_dataset_metadata(metadata, metadata_filename);
}

340
341
// ----------------------------------------------------------------------------------------

342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
void rotate_dataset(const command_line_parser& parser)
{
    image_dataset_metadata::dataset metadata;
    const string datasource = parser[0];
    load_image_dataset_metadata(metadata,datasource);

    double angle = get_option(parser, "rotate", 0);

    // Set the current directory to be the one that contains the
    // metadata file. We do this because the file might contain
    // file paths which are relative to this folder.
    set_current_dir(get_parent_directory(file(datasource)));

    const string file_prefix = "rotated_"+ cast_to_string(angle) + "_";
    const string metadata_filename = get_parent_directory(file(datasource)).full_name() +
        directory::get_separator() + file_prefix + file(datasource).name();


    array2d<rgb_pixel> img, temp;
    for (unsigned long i = 0; i < metadata.images.size(); ++i)
    {
        file f(metadata.images[i].filename);
364
        string filename = get_parent_directory(f).full_name() + directory::get_separator() + file_prefix + to_png_name(f.name());
365
366
367

        load_image(img, metadata.images[i].filename);
        const point_transform_affine tran = rotate_image(img, temp, angle*pi/180);
368
369
370
371
372
373
374
375
376
        if (parser.option("jpg"))
        {
            filename = to_jpg_name(filename);
            save_jpeg(temp, filename,JPEG_QUALITY);
        }
        else
        {
            save_png(temp, filename);
        }
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406

        for (unsigned long j = 0; j < metadata.images[i].boxes.size(); ++j)
        {
            const rectangle rect = metadata.images[i].boxes[j].rect;
            rectangle newrect;
            newrect += tran(rect.tl_corner());
            newrect += tran(rect.tr_corner());
            newrect += tran(rect.bl_corner());
            newrect += tran(rect.br_corner());
            // now make newrect have the same area as the starting rect.
            double ratio = std::sqrt(rect.area()/(double)newrect.area());
            newrect = centered_rect(newrect, newrect.width()*ratio, newrect.height()*ratio);
            metadata.images[i].boxes[j].rect = newrect;

            // rotate all the object parts
            std::map<std::string,point>::iterator k;
            for (k = metadata.images[i].boxes[j].parts.begin(); k != metadata.images[i].boxes[j].parts.end(); ++k)
            {
                k->second = tran(k->second); 
            }
        }

        metadata.images[i].filename = filename;
    }

    save_image_dataset_metadata(metadata, metadata_filename);
}

// ----------------------------------------------------------------------------------------

Davis King's avatar
Davis King committed
407
408
409
410
411
412
413
414
int resample_dataset(const command_line_parser& parser)
{
    if (parser.number_of_arguments() != 1)
    {
        cerr << "The --resample option requires you to give one XML file on the command line." << endl;
        return EXIT_FAILURE;
    }

Davis King's avatar
Davis King committed
415
416
    const size_t obj_size = get_option(parser,"cropped-object-size",100*100); 
    const double margin_scale =  get_option(parser,"crop-size",2.5); // cropped image will be this times wider than the object.
417
    const unsigned long min_object_size = get_option(parser,"min-object-size",1);
418
    const bool one_object_per_image = parser.option("one-object-per-image");
Davis King's avatar
Davis King committed
419
420

    dlib::image_dataset_metadata::dataset data, resampled_data;
Davis King's avatar
Davis King committed
421
422
423
424
425
426
    std::ostringstream sout;
    sout << "\nThe --resample parameters which generated this dataset were:" << endl;
    sout << "   cropped-object-size: "<< obj_size << endl;
    sout << "   crop-size: "<< margin_scale << endl;
    sout << "   min-object-size: "<< min_object_size << endl;
    resampled_data.comment = data.comment + sout.str();
Davis King's avatar
Davis King committed
427
428
429
430
    resampled_data.name = data.name + " RESAMPLED";

    load_image_dataset_metadata(data, parser[0]);
    locally_change_current_dir chdir(get_parent_directory(file(parser[0])));
431
    dlib::rand rnd;
Davis King's avatar
Davis King committed
432

433
434
435
    const size_t image_size = std::round(std::sqrt(obj_size*margin_scale*margin_scale));
    const chip_dims cdims(image_size, image_size);

Davis King's avatar
Davis King committed
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
    console_progress_indicator pbar(data.images.size());
    for (unsigned long i = 0; i < data.images.size(); ++i)
    {
        // don't even bother loading images that don't have objects.
        if (data.images[i].boxes.size() == 0)
            continue;

        pbar.print_status(i);
        array2d<rgb_pixel> img, chip;
        load_image(img, data.images[i].filename);


        // figure out what chips we want to take from this image
        for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
        {
            const rectangle rect = data.images[i].boxes[j].rect;
452
            if (data.images[i].boxes[j].ignore || rect.area() < min_object_size)
Davis King's avatar
Davis King committed
453
454
                continue;

455
            const auto max_dim = std::max(rect.width(), rect.height());
456

457
            const double rand_scale_perturb = 1 - 0.3*(rnd.get_random_double()-0.5);
458
            const rectangle crop_rect = centered_rect(rect, max_dim*margin_scale*rand_scale_perturb, max_dim*margin_scale*rand_scale_perturb);
Davis King's avatar
Davis King committed
459

460
461
            const rectangle_transform tform = get_mapping_to_chip(chip_details(crop_rect, cdims));
            extract_image_chip(img, chip_details(crop_rect, cdims), chip);
Davis King's avatar
Davis King committed
462
463
464
465
466
467
468
469
470
471
472
473
474

            image_dataset_metadata::image dimg;
            // Now transform the boxes to the crop and also mark them as ignored if they
            // have already been cropped out or are outside the crop.
            for (size_t k = 0; k < data.images[i].boxes.size(); ++k)
            {
                image_dataset_metadata::box box = data.images[i].boxes[k];
                // ignore boxes outside the cropped image
                if (crop_rect.intersect(box.rect).area() == 0)
                    continue;

                // mark boxes we include in the crop as ignored.  Also mark boxes that
                // aren't totally within the crop as ignored.
475
                if (crop_rect.contains(grow_rect(box.rect,10)) && (!one_object_per_image || k==j))
Davis King's avatar
Davis King committed
476
477
478
479
                    data.images[i].boxes[k].ignore = true;
                else
                    box.ignore = true;

480
481
482
                if (box.rect.area() < min_object_size)
                    box.ignore = true;

Davis King's avatar
Davis King committed
483
                box.rect = tform(box.rect);
484
485
                for (auto&& p : box.parts)
                    p.second = tform.get_tform()(p.second);
Davis King's avatar
Davis King committed
486
487
                dimg.boxes.push_back(box);
            }
488
489
490
491
492
            // Put a 64bit hash of the image data into the name to make sure there are no
            // file name conflicts.
            std::ostringstream sout;
            sout << hex << murmur_hash3_128bit(&chip[0][0], chip.size()*sizeof(chip[0][0])).second;
            dimg.filename = data.images[i].filename + "_RESAMPLED_"+sout.str()+".png";
Davis King's avatar
Davis King committed
493

494
495
496
497
498
499
500
501
502
            if (parser.option("jpg"))
            {
                dimg.filename = to_jpg_name(dimg.filename);
                save_jpeg(chip,dimg.filename, JPEG_QUALITY);
            }
            else
            {
                save_png(chip,dimg.filename);
            }
Davis King's avatar
Davis King committed
503
504
505
506
507
508
509
510
511
512
            resampled_data.images.push_back(dimg);
        }
    }

    save_image_dataset_metadata(resampled_data, parser[0] + ".RESAMPLED.xml");

    return EXIT_SUCCESS;
}

// ----------------------------------------------------------------------------------------
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529

int tile_dataset(const command_line_parser& parser)
{
    if (parser.number_of_arguments() != 1)
    {
        cerr << "The --tile option requires you to give one XML file on the command line." << endl;
        return EXIT_FAILURE;
    }

    string out_image = parser.option("tile").argument();
    string ext = right_substr(out_image,".");
    if (ext != "png" && ext != "jpg")
    {
        cerr << "The output image file must have either .png or .jpg extension." << endl;
        return EXIT_FAILURE;
    }

530
    const unsigned long chip_size = get_option(parser, "size", 8000);
531
532
533
534
535
536
537
538

    dlib::image_dataset_metadata::dataset data;
    load_image_dataset_metadata(data, parser[0]);
    locally_change_current_dir chdir(get_parent_directory(file(parser[0])));
    dlib::array<array2d<rgb_pixel> > images;
    console_progress_indicator pbar(data.images.size());
    for (unsigned long i = 0; i < data.images.size(); ++i)
    {
Davis King's avatar
Davis King committed
539
540
541
542
        // don't even bother loading images that don't have objects.
        if (data.images[i].boxes.size() == 0)
            continue;

543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
        pbar.print_status(i);
        array2d<rgb_pixel> img;
        load_image(img, data.images[i].filename);

        // figure out what chips we want to take from this image
        std::vector<chip_details> dets;
        for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
        {
            if (data.images[i].boxes[j].ignore)
                continue;

            rectangle rect = data.images[i].boxes[j].rect;
            dets.push_back(chip_details(rect, chip_size));
        }
        // Now grab all those chips at once.
        dlib::array<array2d<rgb_pixel> > chips;
        extract_image_chips(img, dets, chips);
        // and put the chips into the output.
        for (unsigned long j = 0; j < chips.size(); ++j)
            images.push_back(chips[j]);
    }

    chdir.revert();

    if (ext == "png")
        save_png(tile_images(images), out_image);
    else
        save_jpeg(tile_images(images), out_image);

    return EXIT_SUCCESS;
}


Davis King's avatar
Davis King committed
576
577
// ----------------------------------------------------------------------------------------

578
579
580
581
582
int main(int argc, char** argv)
{
    try
    {

Davis King's avatar
Davis King committed
583
        command_line_parser parser;
584
585

        parser.add_option("h","Displays this information.");
586
587
588
        parser.add_option("v","Display version.");

        parser.set_group_name("Creating XML files");
589
        parser.add_option("c","Create an XML file named <arg> listing a set of images.",1);
590
        parser.add_option("r","Search directories recursively for images.");
591
592
593
        parser.add_option("convert","Convert foreign image Annotations from <arg> format to the imglab format. "
                          "Supported formats: pascal-xml, pascal-v1, idl.",1);

594
        parser.set_group_name("Viewing XML files");
595
        parser.add_option("tile","Chip out all the objects and save them as one big image called <arg>.",1);
596
597
        parser.add_option("size","When using --tile or --cluster, make each extracted object contain "
                                 "about <arg> pixels (default 8000).",1);
598
        parser.add_option("l","List all the labels in the given XML file.");
599
        parser.add_option("stats","List detailed statistics on the object labels in the given XML file.");
Davis King's avatar
Davis King committed
600
        parser.add_option("files","List all the files in the given XML file.");
601

Davis King's avatar
Davis King committed
602
        parser.set_group_name("Editing/Transforming XML datasets");
Davis King's avatar
Davis King committed
603
        parser.add_option("rename", "Rename all labels of <arg1> to <arg2>.",2);
604
        parser.add_option("parts","The display will allow image parts to be labeled.  The set of allowable parts "
Davis King's avatar
Davis King committed
605
                          "is defined by <arg> which should be a space separated list of parts.",1);
Davis King's avatar
Davis King committed
606
        parser.add_option("rmempty","Remove all images that don't contain non-ignored annotations and save the results to a new XML file.");
Davis King's avatar
Davis King committed
607
608
        parser.add_option("rmdupes","Remove duplicate images from the dataset.  This is done by comparing "
                                    "the md5 hash of each image file and removing duplicate images. " );
609
610
        parser.add_option("rmdiff","Set the ignored flag to true for boxes marked as difficult.");
        parser.add_option("rmtrunc","Set the ignored flag to true for boxes that are partially outside the image.");
611
612
        parser.add_option("sort-num-objects","Sort the images listed an XML file so images with many objects are listed first.");
        parser.add_option("shuffle","Randomly shuffle the order of the images listed in an XML file.");
613
614
        parser.add_option("seed", "When using --shuffle, set the random seed to the string <arg>.",1);
        parser.add_option("split", "Split the contents of an XML file into two separate files.  One containing the "
615
            "images with objects labeled <arg> and another file with all the other images. ",1);
616
617
618
619
        parser.add_option("add", "Add the image metadata from <arg1> into <arg2>.  If any of the image "
                                 "tags are in both files then the ones in <arg2> are deleted and replaced with the "
                                 "image tags from <arg1>.  The results are saved into merged.xml and neither <arg1> or "
                                 "<arg2> files are modified.",2);
Davis King's avatar
Davis King committed
620
621
        parser.add_option("flip", "Read an XML image dataset from the <arg> XML file and output a left-right flipped "
                                  "version of the dataset and an accompanying flipped XML file named flipped_<arg>.",1);
622
623
        parser.add_option("rotate", "Read an XML image dataset and output a copy that is rotated counter clockwise by <arg> degrees. "
                                  "The output is saved to an XML file prefixed with rotated_<arg>.",1);
624
625
        parser.add_option("cluster", "Cluster all the objects in an XML file into <arg> different clusters and save "
                                     "the results as cluster_###.xml and cluster_###.jpg files.",1);
Davis King's avatar
Davis King committed
626
        parser.add_option("ignore", "Mark boxes labeled as <arg> as ignored.  The resulting XML file is output as a separate file and the original is not modified.",1);
627
628
        parser.add_option("rmlabel","Remove all boxes labeled <arg> and save the results to a new XML file.",1);
        parser.add_option("rm-if-overlaps","Remove all boxes labeled <arg> if they overlap any box not labeled <arg> and save the results to a new XML file.",1);
Davis King's avatar
Davis King committed
629
        parser.add_option("jpg", "When saving images to disk, write them as jpg files instead of png.");
Davis King's avatar
Davis King committed
630
631
632
633
634

        parser.set_group_name("Cropping sub images");
        parser.add_option("resample", "Crop out images that are centered on each object in the dataset. "
                                      "The output is a new XML dataset."); 
        parser.add_option("cropped-object-size", "When doing --resample, make the cropped objects contain about <arg> pixels (default 10000).",1);
635
        parser.add_option("min-object-size", "When doing --resample, skip objects that have fewer than <arg> pixels in them (default 1).",1);
Davis King's avatar
Davis King committed
636
        parser.add_option("crop-size", "When doing --resample, the entire cropped image will be <arg> times wider than the object (default 2.5).",1); 
637
        parser.add_option("one-object-per-image", "When doing --resample, only include one non-ignored object per image (i.e. the central object).");
Davis King's avatar
Davis King committed
638
639


640
641
642

        parser.parse(argc, argv);

Davis King's avatar
Davis King committed
643
        const char* singles[] = {"h","c","r","l","files","convert","parts","rmdiff", "rmtrunc", "rmdupes", "seed", "shuffle", "split", "add", 
Davis King's avatar
Davis King committed
644
                                 "flip", "rotate", "tile", "size", "cluster", "resample", "min-object-size", "rmempty",
645
                                 "crop-size", "cropped-object-size", "rmlabel", "rm-if-overlaps", "sort-num-objects", "one-object-per-image", "jpg"};
646
        parser.check_one_time_options(singles);
647
648
        const char* c_sub_ops[] = {"r", "convert"};
        parser.check_sub_options("c", c_sub_ops);
649
        parser.check_sub_option("shuffle", "seed");
650
        const char* resample_sub_ops[] = {"min-object-size", "crop-size", "cropped-object-size", "one-object-per-image"};
Davis King's avatar
Davis King committed
651
        parser.check_sub_options("resample", resample_sub_ops);
652
653
        const char* size_parent_ops[] = {"tile", "cluster"};
        parser.check_sub_options(size_parent_ops, "size");
Davis King's avatar
Davis King committed
654
        parser.check_incompatible_options("c", "l");
Davis King's avatar
Davis King committed
655
        parser.check_incompatible_options("c", "files");
656
        parser.check_incompatible_options("c", "rmdiff");
Davis King's avatar
Davis King committed
657
        parser.check_incompatible_options("c", "rmempty");
658
659
        parser.check_incompatible_options("c", "rmlabel");
        parser.check_incompatible_options("c", "rm-if-overlaps");
Davis King's avatar
Davis King committed
660
        parser.check_incompatible_options("c", "rmdupes");
661
        parser.check_incompatible_options("c", "rmtrunc");
662
        parser.check_incompatible_options("c", "add");
Davis King's avatar
Davis King committed
663
        parser.check_incompatible_options("c", "flip");
664
        parser.check_incompatible_options("c", "rotate");
Davis King's avatar
Davis King committed
665
        parser.check_incompatible_options("c", "rename");
666
        parser.check_incompatible_options("c", "ignore");
667
        parser.check_incompatible_options("c", "parts");
668
        parser.check_incompatible_options("c", "tile");
669
        parser.check_incompatible_options("c", "cluster");
Davis King's avatar
Davis King committed
670
        parser.check_incompatible_options("c", "resample");
Davis King's avatar
Davis King committed
671
        parser.check_incompatible_options("l", "rename");
672
        parser.check_incompatible_options("l", "ignore");
673
        parser.check_incompatible_options("l", "add");
674
        parser.check_incompatible_options("l", "parts");
Davis King's avatar
Davis King committed
675
        parser.check_incompatible_options("l", "flip");
676
        parser.check_incompatible_options("l", "rotate");
Davis King's avatar
Davis King committed
677
678
679
680
681
682
        parser.check_incompatible_options("files", "rename");
        parser.check_incompatible_options("files", "ignore");
        parser.check_incompatible_options("files", "add");
        parser.check_incompatible_options("files", "parts");
        parser.check_incompatible_options("files", "flip");
        parser.check_incompatible_options("files", "rotate");
Davis King's avatar
Davis King committed
683
        parser.check_incompatible_options("add", "flip");
684
        parser.check_incompatible_options("add", "rotate");
685
686
        parser.check_incompatible_options("add", "tile");
        parser.check_incompatible_options("flip", "tile");
687
        parser.check_incompatible_options("rotate", "tile");
688
        parser.check_incompatible_options("cluster", "tile");
Davis King's avatar
Davis King committed
689
        parser.check_incompatible_options("resample", "tile");
690
        parser.check_incompatible_options("flip", "cluster");
691
        parser.check_incompatible_options("rotate", "cluster");
692
        parser.check_incompatible_options("add", "cluster");
Davis King's avatar
Davis King committed
693
694
695
        parser.check_incompatible_options("flip", "resample");
        parser.check_incompatible_options("rotate", "resample");
        parser.check_incompatible_options("add", "resample");
696
        parser.check_incompatible_options("shuffle", "tile");
697
        parser.check_incompatible_options("sort-num-objects", "tile");
698
        parser.check_incompatible_options("convert", "l");
Davis King's avatar
Davis King committed
699
        parser.check_incompatible_options("convert", "files");
700
        parser.check_incompatible_options("convert", "rename");
701
        parser.check_incompatible_options("convert", "ignore");
702
        parser.check_incompatible_options("convert", "parts");
703
        parser.check_incompatible_options("convert", "cluster");
Davis King's avatar
Davis King committed
704
        parser.check_incompatible_options("convert", "resample");
705
        parser.check_incompatible_options("rmdiff", "rename");
706
        parser.check_incompatible_options("rmdiff", "ignore");
Davis King's avatar
Davis King committed
707
708
        parser.check_incompatible_options("rmempty", "ignore");
        parser.check_incompatible_options("rmempty", "rename");
709
710
711
712
        parser.check_incompatible_options("rmlabel", "ignore");
        parser.check_incompatible_options("rmlabel", "rename");
        parser.check_incompatible_options("rm-if-overlaps", "ignore");
        parser.check_incompatible_options("rm-if-overlaps", "rename");
Davis King's avatar
Davis King committed
713
        parser.check_incompatible_options("rmdupes", "rename");
714
        parser.check_incompatible_options("rmdupes", "ignore");
715
        parser.check_incompatible_options("rmtrunc", "rename");
716
        parser.check_incompatible_options("rmtrunc", "ignore");
717
        const char* convert_args[] = {"pascal-xml","pascal-v1","idl"};
718
        parser.check_option_arg_range("convert", convert_args);
719
        parser.check_option_arg_range("cluster", 2, 999);
Davis King's avatar
Davis King committed
720
        parser.check_option_arg_range("rotate", -360, 360);
721
        parser.check_option_arg_range("size", 10*10, 1000*1000);
722
        parser.check_option_arg_range("min-object-size", 1, 10000*10000);
Davis King's avatar
Davis King committed
723
724
        parser.check_option_arg_range("cropped-object-size", 4, 10000*10000);
        parser.check_option_arg_range("crop-size", 1.0, 100.0);
725
726
727

        if (parser.option("h"))
        {
728
            cout << "Usage: imglab [options] <image files/directories or XML file>\n";
729
            parser.print_options(cout);
Davis King's avatar
Davis King committed
730
            cout << endl << endl;
731
732
733
            return EXIT_SUCCESS;
        }

734
735
736
737
738
739
        if (parser.option("add"))
        {
            merge_metadata_files(parser);
            return EXIT_SUCCESS;
        }

Davis King's avatar
Davis King committed
740
741
742
743
744
745
        if (parser.option("flip"))
        {
            flip_dataset(parser);
            return EXIT_SUCCESS;
        }

746
747
748
749
750
751
        if (parser.option("rotate"))
        {
            rotate_dataset(parser);
            return EXIT_SUCCESS;
        }

Davis King's avatar
Davis King committed
752
753
754
755
756
757
758
759
760
        if (parser.option("v"))
        {
            cout << "imglab v" << VERSION 
                 << "\nCompiled: " << __TIME__ << " " << __DATE__ 
                 << "\nWritten by Davis King\n";
            cout << "Check for updates at http://dlib.net\n\n";
            return EXIT_SUCCESS;
        }

761
762
763
764
765
        if (parser.option("tile"))
        {
            return tile_dataset(parser);
        }

766
767
768
769
770
        if (parser.option("cluster"))
        {
            return cluster_dataset(parser);
        }

Davis King's avatar
Davis King committed
771
772
773
774
775
        if (parser.option("resample"))
        {
            return resample_dataset(parser);
        }

776
777
        if (parser.option("c"))
        {
778
779
            if (parser.option("convert"))
            {
Davis King's avatar
Davis King committed
780
781
                if (parser.option("convert").argument() == "pascal-xml")
                    convert_pascal_xml(parser);
782
783
                else if (parser.option("convert").argument() == "pascal-v1")
                    convert_pascal_v1(parser);
784
785
                else if (parser.option("convert").argument() == "idl")
                    convert_idl(parser);
786
787
788
789
790
            }
            else
            {
                create_new_dataset(parser);
            }
791
792
            return EXIT_SUCCESS;
        }
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
        
        if (parser.option("rmdiff"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --rmdiff option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            for (unsigned long i = 0; i < data.images.size(); ++i)
            {
                for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
                {
808
809
810
811
812
813
814
815
                    if (data.images[i].boxes[j].difficult)
                        data.images[i].boxes[j].ignore = true;
                }
            }
            save_image_dataset_metadata(data, parser[0]);
            return EXIT_SUCCESS;
        }

Davis King's avatar
Davis King committed
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
        if (parser.option("rmempty"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --rmempty option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data, data2;
            load_image_dataset_metadata(data, parser[0]);

            data2 = data;
            data2.images.clear();
            for (unsigned long i = 0; i < data.images.size(); ++i)
            {
                bool has_label = false;
                for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
                {
                    if (!data.images[i].boxes[j].ignore)
                        has_label = true;
                }
                if (has_label)
                    data2.images.push_back(data.images[i]);
            }
            save_image_dataset_metadata(data2, parser[0] + ".rmempty.xml");
            return EXIT_SUCCESS;
        }

844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
        if (parser.option("rmlabel"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --rmlabel option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);

            const auto label = parser.option("rmlabel").argument();

            for (auto&& img : data.images)
            {
                std::vector<dlib::image_dataset_metadata::box> boxes;
                for (auto&& b : img.boxes)
                {
                    if (b.label != label)
                        boxes.push_back(b);
                }
                img.boxes = boxes;
            }

            save_image_dataset_metadata(data, parser[0] + ".rmlabel-"+label+".xml");
            return EXIT_SUCCESS;
        }

        if (parser.option("rm-if-overlaps"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --rm-if-overlaps option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);

            const auto label = parser.option("rm-if-overlaps").argument();

885
            test_box_overlap overlaps(0.5);
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917

            for (auto&& img : data.images)
            {
                std::vector<dlib::image_dataset_metadata::box> boxes;
                for (auto&& b : img.boxes)
                {
                    if (b.label != label)
                    {
                        boxes.push_back(b);
                    }
                    else
                    {
                        bool has_overlap = false;
                        for (auto&& b2 : img.boxes)
                        {
                            if (b2.label != label && overlaps(b2.rect, b.rect))
                            {
                                has_overlap = true;
                                break;
                            }
                        }
                        if (!has_overlap)
                            boxes.push_back(b);
                    }
                }
                img.boxes = boxes;
            }

            save_image_dataset_metadata(data, parser[0] + ".rm-if-overlaps-"+label+".xml");
            return EXIT_SUCCESS;
        }

Davis King's avatar
Davis King committed
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
        if (parser.option("rmdupes"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --rmdupes option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data, data_out;
            std::set<std::string> hashes;
            load_image_dataset_metadata(data, parser[0]);
            data_out = data;
            data_out.images.clear();

            for (unsigned long i = 0; i < data.images.size(); ++i)
            {
                ifstream fin(data.images[i].filename.c_str(), ios::binary);
                string hash = md5(fin);
                if (hashes.count(hash) == 0)
                {
                    hashes.insert(hash);
                    data_out.images.push_back(data.images[i]);
                }
            }
            save_image_dataset_metadata(data_out, parser[0]);
            return EXIT_SUCCESS;
        }

946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
        if (parser.option("rmtrunc"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --rmtrunc option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            {
                locally_change_current_dir chdir(get_parent_directory(file(parser[0])));
                for (unsigned long i = 0; i < data.images.size(); ++i)
                {
                    array2d<unsigned char> img;
                    load_image(img, data.images[i].filename);
                    const rectangle area = get_rect(img);
                    for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j)
                    {
                        if (!area.contains(data.images[i].boxes[j].rect))
                            data.images[i].boxes[j].ignore = true;
                    }
968
969
970
971
972
                }
            }
            save_image_dataset_metadata(data, parser[0]);
            return EXIT_SUCCESS;
        }
973

974
975
976
977
978
979
980
981
982
983
984
985
986
987
        if (parser.option("l"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The -l option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            print_all_labels(data);
            return EXIT_SUCCESS;
        }

Davis King's avatar
Davis King committed
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
        if (parser.option("files"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --files option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            for (size_t i = 0; i < data.images.size(); ++i)
                cout << data.images[i].filename << "\n";
            return EXIT_SUCCESS;
        }

1003
1004
1005
1006
1007
1008
1009
1010
1011
        if (parser.option("split"))
        {
            return split_dataset(parser);
        }

        if (parser.option("shuffle"))
        {
            if (parser.number_of_arguments() != 1)
            {
1012
                cerr << "The --shuffle option requires you to give one XML file on the command line." << endl;
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            const string default_seed = cast_to_string(time(0));
            const string seed = get_option(parser, "seed", default_seed);
            dlib::rand rnd(seed);
            randomize_samples(data.images, rnd);
            save_image_dataset_metadata(data, parser[0]);
            return EXIT_SUCCESS;
        }

1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
        if (parser.option("sort-num-objects"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --sort-num-objects option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            std::sort(data.images.rbegin(),  data.images.rend(), 
                [](const image_dataset_metadata::image& a, const image_dataset_metadata::image& b) { return a.boxes.size() < b.boxes.size(); });
            save_image_dataset_metadata(data, parser[0]);
            return EXIT_SUCCESS;
        }

1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
        if (parser.option("stats"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --stats option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            print_all_label_stats(data);
            return EXIT_SUCCESS;
        }

Davis King's avatar
Davis King committed
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
        if (parser.option("rename"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --rename option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            for (unsigned long i = 0; i < parser.option("rename").count(); ++i)
            {
                rename_labels(data, parser.option("rename").argument(0,i), parser.option("rename").argument(1,i));
            }
            save_image_dataset_metadata(data, parser[0]);
            return EXIT_SUCCESS;
        }

1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
        if (parser.option("ignore"))
        {
            if (parser.number_of_arguments() != 1)
            {
                cerr << "The --ignore option requires you to give one XML file on the command line." << endl;
                return EXIT_FAILURE;
            }

            dlib::image_dataset_metadata::dataset data;
            load_image_dataset_metadata(data, parser[0]);
            for (unsigned long i = 0; i < parser.option("ignore").count(); ++i)
            {
                ignore_labels(data, parser.option("ignore").argument());
            }
            save_image_dataset_metadata(data, parser[0]+".ignored.xml");
            return EXIT_SUCCESS;
        }

1092
1093
        if (parser.number_of_arguments() == 1)
        {
1094
            metadata_editor editor(parser[0]);
1095
1096
1097
1098
1099
1100
1101
1102
            if (parser.option("parts"))
            {
                std::vector<string> parts = split(parser.option("parts").argument());
                for (unsigned long i = 0; i < parts.size(); ++i)
                {
                    editor.add_labelable_part_name(parts[i]);
                }
            }
1103
            editor.wait_until_closed();
1104
            return EXIT_SUCCESS;
1105
        }
Davis King's avatar
Davis King committed
1106
1107
1108

        cout << "Invalid command, give -h to see options." << endl;
        return EXIT_FAILURE;
1109
1110
1111
    }
    catch (exception& e)
    {
1112
        cerr << e.what() << endl;
1113
1114
1115
1116
        return EXIT_FAILURE;
    }
}

Davis King's avatar
Davis King committed
1117
1118
// ----------------------------------------------------------------------------------------