version:2.1.5

bugfixes:
update:拨号使用ocr进行识别

app/OpenCV/sdk/native/jni/include/opencv2/flann/heap.h

@@ -36,7 +36,8 @@
 #include <algorithm>
 #include <vector>
 
-namespace cvflann {
+namespace cvflann
+{
 
 /**
  * Priority Queue Implementation
@@ -45,111 +46,122 @@ namespace cvflann {
  * (full) binary tree in which each parent is less than both of its
  * children, but the order of the children is unspecified.
  */
-    template<typename T>
-    class Heap {
+template <typename T>
+class Heap
+{
 
-        /**
-         * Storage array for the heap.
-         * Type T must be comparable.
-         */
-        std::vector<T> heap;
-        int length;
+    /**
+     * Storage array for the heap.
+     * Type T must be comparable.
+     */
+    std::vector<T> heap;
+    int length;
 
-        /**
-         * Number of element in the heap
-         */
-        int count;
+    /**
+     * Number of element in the heap
+     */
+    int count;
 
 
-    public:
-        /**
-         * Constructor.
-         *
-         * Params:
-         *     sz = heap size
-         */
 
-        Heap(int sz) {
-            length = sz;
-            heap.reserve(length);
-            count = 0;
-        }
+public:
+    /**
+     * Constructor.
+     *
+     * Params:
+     *     sz = heap size
+     */
 
-        /**
-         *
-         * Returns: heap size
-         */
-        int size() {
-            return count;
-        }
+    Heap(int sz)
+    {
+        length = sz;
+        heap.reserve(length);
+        count = 0;
+    }
 
-        /**
-         * Tests if the heap is empty
-         *
-         * Returns: true is heap empty, false otherwise
-         */
-        bool empty() {
-            return size() == 0;
-        }
+    /**
+     *
+     * Returns: heap size
+     */
+    int size()
+    {
+        return count;
+    }
 
-        /**
-         * Clears the heap.
-         */
-        void clear() {
-            heap.clear();
-            count = 0;
-        }
+    /**
+     * Tests if the heap is empty
+     *
+     * Returns: true is heap empty, false otherwise
+     */
+    bool empty()
+    {
+        return size()==0;
+    }
 
-        struct CompareT {
-            bool operator()(const T &t_1, const T &t_2) const {
-                return t_2 < t_1;
-            }
-        };
+    /**
+     * Clears the heap.
+     */
+    void clear()
+    {
+        heap.clear();
+        count = 0;
+    }
 
-        /**
-         * Insert a new element in the heap.
-         *
-         * We select the next empty leaf node, and then keep moving any larger
-         * parents down until the right location is found to store this element.
-         *
-         * Params:
-         *     value = the new element to be inserted in the heap
-         */
-        void insert(T value) {
-            /* If heap is full, then return without adding this element. */
-            if (count == length) {
-                return;
-            }
-
-            heap.push_back(value);
-            static CompareT compareT;
-            std::push_heap(heap.begin(), heap.end(), compareT);
-            ++count;
-        }
-
-
-        /**
-         * Returns the node of minimum value from the heap (top of the heap).
-         *
-         * Params:
-         *     value = out parameter used to return the min element
-         * Returns: false if heap empty
-         */
-        bool popMin(T &value) {
-            if (count == 0) {
-                return false;
-            }
-
-            value = heap[0];
-            static CompareT compareT;
-            std::pop_heap(heap.begin(), heap.end(), compareT);
-            heap.pop_back();
-            --count;
-
-            return true;  /* Return old last node. */
+    struct CompareT
+    {
+        bool operator()(const T& t_1, const T& t_2) const
+        {
+            return t_2 < t_1;
         }
     };
 
+    /**
+     * Insert a new element in the heap.
+     *
+     * We select the next empty leaf node, and then keep moving any larger
+     * parents down until the right location is found to store this element.
+     *
+     * Params:
+     *     value = the new element to be inserted in the heap
+     */
+    void insert(T value)
+    {
+        /* If heap is full, then return without adding this element. */
+        if (count == length) {
+            return;
+        }
+
+        heap.push_back(value);
+        static CompareT compareT;
+        std::push_heap(heap.begin(), heap.end(), compareT);
+        ++count;
+    }
+
+
+
+    /**
+     * Returns the node of minimum value from the heap (top of the heap).
+     *
+     * Params:
+     *     value = out parameter used to return the min element
+     * Returns: false if heap empty
+     */
+    bool popMin(T& value)
+    {
+        if (count == 0) {
+            return false;
+        }
+
+        value = heap[0];
+        static CompareT compareT;
+        std::pop_heap(heap.begin(), heap.end(), compareT);
+        heap.pop_back();
+        --count;
+
+        return true;  /* Return old last node. */
+    }
+};
+
 }
 
 //! @endcond