Added the ability to convert from the PASCAL VOC annotation format to the

imglab annotation format.

tools/imglab/CMakeLists.txt

@@ -18,6 +18,10 @@ ADD_EXECUTABLE(${target_name}
    src/image_dataset_metadata.cpp
    src/metadata_editor.h
    src/metadata_editor.cpp
+   src/convert_pascal_voc.h
+   src/convert_pascal_voc.cpp
+   src/common.h
+   src/common.cpp
 )
 
 

tools/imglab/src/common.cpp

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+
+#include "common.h"
+#include <fstream>
+
+// ----------------------------------------------------------------------------------------
+
+std::string strip_path (
+    const std::string& str,
+    const std::string& prefix
+)
+{
+    unsigned long i;
+    for (i = 0; i < str.size() && i < prefix.size(); ++i)
+    {
+        if (str[i] != prefix[i]) 
+            return str;
+    }
+
+    if (i < str.size() && (str[i] == '/' || str[i] == '\\'))
+        ++i;
+
+    return str.substr(i);
+}
+
+// ----------------------------------------------------------------------------------------
+
+void make_empty_file (
+    const std::string& filename
+)
+{
+    std::ofstream fout(filename.c_str());
+    if (!fout)
+        throw dlib::error("ERROR: Unable to open " + filename + " for writing.");
+}
+
+// ----------------------------------------------------------------------------------------
+

tools/imglab/src/common.h

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_IMGLAB_COmMON_H__
+#define DLIB_IMGLAB_COmMON_H__
+
+#include <string>
+#include <dlib/cmd_line_parser.h>
+typedef dlib::cmd_line_parser<char>::check_1a_c parser_type;
+
+// ----------------------------------------------------------------------------------------
+
+std::string strip_path (
+    const std::string& str,
+    const std::string& prefix
+);
+/*!
+    ensures
+        - if (prefix is a prefix of str) then
+            - returns the part of str after the prefix
+              (additionally, str will not begin with a / or \ character)
+        - else
+            - return str
+!*/
+
+// ----------------------------------------------------------------------------------------
+
+void make_empty_file (
+    const std::string& filename
+);
+/*!
+    ensures
+        - creates an empty file of the given name
+!*/
+
+// ----------------------------------------------------------------------------------------
+
+#endif // DLIB_IMGLAB_COmMON_H__
+

tools/imglab/src/convert_pascal_voc.cpp

+
+#include "convert_pascal_voc.h"
+#include "image_dataset_metadata.h"
+#include <iostream>
+#include <dlib/xml_parser.h>
+#include <string>
+#include <dlib/dir_nav.h>
+
+using namespace std;
+using namespace dlib;
+
+namespace
+{
+    using namespace dlib::image_dataset_metadata;
+
+// ----------------------------------------------------------------------------------------
+
+    class doc_handler : public document_handler
+    {
+        image& temp_image;
+        std::string& dataset_name;
+
+        std::vector<std::string> ts;
+        box temp_box;
+
+    public:
+
+        doc_handler(
+            image& temp_image_,
+            std::string& dataset_name_
+        ):
+            temp_image(temp_image_),
+            dataset_name(dataset_name_)
+        {}
+
+
+        virtual void start_document (
+        )
+        {
+            ts.clear();
+            temp_image = image();
+            temp_box = box();
+            dataset_name.clear();
+        }
+
+        virtual void end_document (
+        )
+        {
+        }
+
+        virtual void start_element ( 
+            const unsigned long line_number,
+            const std::string& name,
+            const dlib::attribute_list& atts
+        )
+        {
+            if (ts.size() == 0 && name != "annotation") 
+            {
+                std::ostringstream sout;
+                sout << "Invalid XML document.  Root tag must be <annotation>.  Found <" << name << "> instead.";
+                throw dlib::error(sout.str());
+            }
+
+
+            ts.push_back(name);
+        }
+
+        virtual void end_element ( 
+            const unsigned long line_number,
+            const std::string& name
+        )
+        {
+            ts.pop_back();
+            if (ts.size() == 0)
+                return;
+
+            if (name == "object" && ts.back() == "annotation")
+            {
+                temp_image.boxes.push_back(temp_box);
+                temp_box = box();
+            }
+        }
+
+        virtual void characters ( 
+            const std::string& data
+        )
+        {
+            if (ts.size() == 2 && ts[1] == "filename")
+            {
+                temp_image.filename = trim(data);
+            }
+            else if (ts.size() == 3 && ts[2] == "database" && ts[1] == "source")
+            {
+                dataset_name = trim(data);
+            }
+            else if (ts.size() >= 3)
+            {
+                if (ts[ts.size()-2] == "bndbox" && ts[ts.size()-3] == "object")
+                {
+                    if      (ts.back() == "xmin") temp_box.rect.left()   = string_cast<double>(data);
+                    else if (ts.back() == "ymin") temp_box.rect.top()    = string_cast<double>(data);
+                    else if (ts.back() == "xmax") temp_box.rect.right()  = string_cast<double>(data);
+                    else if (ts.back() == "ymax") temp_box.rect.bottom() = string_cast<double>(data);
+                }
+                else if (ts.back() == "name" && ts[ts.size()-2] == "object")
+                {
+                    temp_box.label = trim(data);
+                }
+
+            }
+        }
+
+        virtual void processing_instruction (
+            const unsigned long ,
+            const std::string& ,
+            const std::string& 
+        )
+        {
+        }
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    class xml_error_handler : public error_handler
+    {
+    public:
+        virtual void error (
+            const unsigned long 
+        ) { }
+
+        virtual void fatal_error (
+            const unsigned long line_number
+        )
+        {
+            std::ostringstream sout;
+            sout << "There is a fatal error on line " << line_number << " so parsing will now halt.";
+            throw dlib::error(sout.str());
+        }
+    };
+
+// ----------------------------------------------------------------------------------------
+
+    void parse_annotation_file(
+        const std::string& file,
+        dlib::image_dataset_metadata::image& img,
+        std::string& dataset_name
+    )
+    {
+        doc_handler dh(img, dataset_name);
+        xml_error_handler eh;
+
+        xml_parser::kernel_1a parser;
+        parser.add_document_handler(dh);
+        parser.add_error_handler(eh);
+
+        ifstream fin(file.c_str());
+        if (!fin)
+            throw dlib::error("Unable to open file " + file);
+        parser.parse(fin);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+void convert_pascal_voc(
+    const parser_type& parser
+)
+{
+    cout << "Convert from PASCAL VOC annotation format..." << endl;
+
+    dlib::image_dataset_metadata::dataset dataset;
+
+    std::string name;
+    dlib::image_dataset_metadata::image img;
+
+    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);
+    const std::string parent_dir = get_parent_directory(file(filename)).full_name();
+
+    for (unsigned long i = 0; i < parser.number_of_arguments(); ++i)
+    {
+        try
+        {
+            parse_annotation_file(parser[i], img, name);
+            const string voc_root = get_parent_directory(get_parent_directory(file(parser[i]))).full_name();
+            const string img_path = voc_root + directory::get_separator() + "JPEGImages" + directory::get_separator();
+
+            dataset.name = name;
+            img.filename = strip_path(img_path + img.filename,  parent_dir);
+            dataset.images.push_back(img);
+
+        }
+        catch (exception& e)
+        {
+            cout << "Error while processing file " << parser[i] << endl << endl;
+            throw;
+        }
+    }
+
+    save_image_dataset_metadata(dataset, filename);
+}
+

tools/imglab/src/convert_pascal_voc.h

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_IMGLAB_CONVERT_PASCAl_VOC_H__
+#define DLIB_IMGLAB_CONVERT_PASCAl_VOC_H__
+
+#include "common.h"
+
+void convert_pascal_voc(const parser_type& parser);
+
+#endif // DLIB_IMGLAB_CONVERT_PASCAl_VOC_H__
+

tools/imglab/src/main.cpp

 
 #include "image_dataset_metadata.h"
 #include "metadata_editor.h"
+#include "convert_pascal_voc.h"
 
 #include <iostream>
 #include <fstream>
 #include <string>
 #include <set>
 
-#include <dlib/cmd_line_parser.h>
 #include <dlib/dir_nav.h>
 
 
 const char* VERSION = "0.1";
 
 
-typedef dlib::cmd_line_parser<char>::check_1a_c parser_type;
 
 using namespace std;
 using namespace dlib;
 
 // ----------------------------------------------------------------------------------------
 
-std::string strip_path (
-    const std::string& str,
-    const std::string& prefix
-)
-{
-    unsigned long i;
-    for (i = 0; i < str.size() && i < prefix.size(); ++i)
-    {
-        if (str[i] != prefix[i]) 
-            return str;
-    }
-
-    if (i < str.size() && (str[i] == '/' || str[i] == '\\'))
-        ++i;
-
-    return str.substr(i);
-}
-
-// ----------------------------------------------------------------------------------------
-
-void make_empty_file (
-    const std::string& filename
-)
-{
-    ofstream fout(filename.c_str());
-    if (!fout)
-        throw dlib::error("ERROR: Unable to open " + filename + " for writing.");
-}
-
-// ----------------------------------------------------------------------------------------
-
 void create_new_dataset (
     const parser_type& parser
 )
@@ -155,15 +123,22 @@ int main(int argc, char** argv)
         parser.add_option("l","List all the labels in the given XML file.");
         parser.add_option("rename", "Rename all labels of <arg1> to <arg2>.",2);
         parser.add_option("v","Display version.");
+        parser.add_option("convert","Convert foreign image Annotations from <arg> format to the imglab format. "
+                          "Supported formats: pascal-voc",1);
 
         parser.parse(argc, argv);
 
-        const char* singles[] = {"h","c","r","l"};
+        const char* singles[] = {"h","c","r","l","convert"};
         parser.check_one_time_options(singles);
-        parser.check_sub_option("c", "r");
+        const char* c_sub_ops[] = {"r", "convert"};
+        parser.check_sub_options("c", c_sub_ops);
         parser.check_incompatible_options("c", "l");
         parser.check_incompatible_options("c", "rename");
         parser.check_incompatible_options("l", "rename");
+        parser.check_incompatible_options("convert", "l");
+        parser.check_incompatible_options("convert", "rename");
+        const char* convert_args[] = {"pascal-voc"};
+        parser.check_option_arg_range("convert", convert_args);
 
         if (parser.option("h"))
         {
@@ -184,7 +159,17 @@ int main(int argc, char** argv)
 
         if (parser.option("c"))
         {
-            create_new_dataset(parser);
+            if (parser.option("convert"))
+            {
+                if (parser.option("convert").argument() == "pascal-voc")
+                {
+                    convert_pascal_voc(parser);
+                }
+            }
+            else
+            {
+                create_new_dataset(parser);
+            }
             return EXIT_SUCCESS;
         }