svn propset svn:eol-style native *.h *.cpp

diff --git a/src/trace/siox.h b/src/trace/siox.h
index 4020fe343d8c9d77f78321e6d2b6ca4f8d85bc9e..d6efbfba1de0c4195bfb2312731f5869ddb384dd 100644 (file)
--- a/src/trace/siox.h
+++ b/src/trace/siox.h
@@ -1,396 +1,396 @@
-#ifndef __SIOX_SEGMENTATOR_H__\r
-#define __SIOX_SEGMENTATOR_H__\r
-/*\r
-   Copyright 2005, 2006 by Gerald Friedland, Kristian Jantz and Lars Knipping\r
-\r
-   Conversion to C++ for Inkscape by Bob Jamison\r
-\r
-   Licensed under the Apache License, Version 2.0 (the "License");\r
-   you may not use this file except in compliance with the License.\r
-   You may obtain a copy of the License at\r
-\r
-   http://www.apache.org/licenses/LICENSE-2.0\r
-\r
-   Unless required by applicable law or agreed to in writing, software\r
-   distributed under the License is distributed on an "AS IS" BASIS,\r
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
-   See the License for the specific language governing permissions and\r
-   limitations under the License.\r
- */\r
-\r
-#include <map>\r
-#include <vector>\r
-\r
-namespace org\r
-{\r
-namespace siox\r
-{\r
-\r
-/**\r
- * Image segmentator based on\r
- *<em>SIOX: Simple Interactive Object Extraction</em>.\r
- * <P>\r
- * To segmentate an image one has to perform the following steps.\r
- * <OL><LI>Construct an instance of <code>SioxSegmentator</code>.\r
- * </LI><LI>Create a confidence matrix, where each entry marks its\r
- *      corresponding image pixel to belong to the foreground, to the\r
- *      background, or being of unknown type.\r
- * </LI><LI>Call <code>segmentate</code> on the image with the confidence\r
- *       matrix. This stores the result as new foreground confidence into\r
- *       the confidence matrix, with each entry being either\r
- *       zero (<code>CERTAIN_BACKGROUND_CONFIDENCE</code>) or one\r
- *       (<code>CERTAIN_FOREGROUND_CONFIDENCE</code>).\r
- * </LI><LI>Optionally call <code>subpixelRefine</code> to areas\r
- *      where pixels contain both foreground and background (e.g.\r
- *      object borders or highly detailed features like flowing hairs).\r
- *      The pixel are then assigned confidence values bwetween zero and\r
- *      one to give them a measure of "foregroundness".\r
- *      This step may be repeated as often as needed.\r
- * </LI></OL>\r
- * <P>\r
- * For algorithm documentation refer to\r
- * G. Friedland, K. Jantz, L. Knipping, R. Rojas:<i>\r
- * Image Segmentation by Uniform Color Clustering\r
- *  -- Approach and Benchmark Results</i>,\r
- * <A HREF="http://www.inf.fu-berlin.de/inst/pubs/tr-b-05-07.pdf">Technical Report B-05-07</A>,\r
- * Department of Computer Science, Freie Universitaet Berlin, June 2005.<br>\r
- * <P>\r
- * See <A HREF="http://www.siox.org/" target="_new">http://www.siox.org</A> for more information.<br>\r
- * <P>\r
- * Algorithm idea by Gerald Friedland.\r
- *\r
- * @author Gerald Friedland, Kristian Jantz, Lars Knipping\r
- * @version 1.12\r
- */\r
-\r
-/**\r
- * Helper class for storing the minimum distances to a cluster centroid\r
- * in background and foreground and the index to the centroids in each\r
- * signature for a given color.\r
- */\r
-class Tupel {\r
-public:\r
-\r
-    Tupel()\r
-        {\r
-        minBgDist  = 0.0f;\r
-        indexMinBg = 0;\r
-        minFgDist  = 0.0f;\r
-        indexMinFg = 0;\r
-        }\r
-    Tupel(float minBgDistArg, long indexMinBgArg,\r
-          float minFgDistArg, long indexMinFgArg)\r
-        {\r
-       minBgDist  = minBgDistArg;\r
-       indexMinBg = indexMinBgArg;\r
-       minFgDist  = minFgDistArg;\r
-       indexMinFg = indexMinFgArg;\r
-        }\r
-    Tupel(const Tupel &other)\r
-        {\r
-       minBgDist  = other.minBgDist;\r
-       indexMinBg = other.indexMinBg;\r
-       minFgDist  = other.minFgDist;\r
-       indexMinFg = other.indexMinFg;\r
-        }\r
-    Tupel &operator=(const Tupel &other)\r
-        {\r
-       minBgDist  = other.minBgDist;\r
-       indexMinBg = other.indexMinBg;\r
-       minFgDist  = other.minFgDist;\r
-       indexMinFg = other.indexMinFg;\r
-       return *this;\r
-        }\r
-    virtual ~Tupel()\r
-        {}\r
-\r
-    float minBgDist;\r
-    long  indexMinBg;\r
-    float minFgDist;\r
-    long  indexMinFg;\r
-\r
- };\r
-\r
-\r
-class CLAB\r
-{\r
-public:\r
-    CLAB()\r
-        {\r
-        C = L = A = B = 0.0f;\r
-        }\r
-    CLAB(float lArg, float aArg, float bArg)\r
-        {\r
-        C = 0.0f;\r
-        L = lArg;\r
-        A = aArg;\r
-        B = bArg;\r
-        }\r
-    CLAB(const CLAB &other)\r
-        {\r
-        C = other.C;\r
-        L = other.L;\r
-        A = other.A;\r
-        B = other.B;\r
-        }\r
-    CLAB &operator=(const CLAB &other)\r
-        {\r
-        C = other.C;\r
-        L = other.L;\r
-        A = other.A;\r
-        B = other.B;\r
-        return *this;\r
-        }\r
-    virtual ~CLAB()\r
-        {}\r
-\r
-    float C;\r
-    float L;\r
-    float A;\r
-    float B;\r
-};\r
-\r
-\r
-class SioxSegmentator\r
-{\r
-public:\r
-\r
-    /** Confidence corresponding to a certain foreground region (equals one). */\r
-    static const float CERTAIN_FOREGROUND_CONFIDENCE;  //=1.0f;\r
-\r
-    /** Confidence for a region likely being foreground.*/\r
-    static const float FOREGROUND_CONFIDENCE;  //=0.8f;\r
-\r
-    /** Confidence for foreground or background type being equally likely.*/\r
-    static const float UNKNOWN_REGION_CONFIDENCE;  //=0.5f;\r
-\r
-    /** Confidence for a region likely being background.*/\r
-    static const float BACKGROUND_CONFIDENCE;  //=0.1f;\r
-\r
-    /** Confidence corresponding to a certain background reagion (equals zero). */\r
-    static const float CERTAIN_BACKGROUND_CONFIDENCE;  //=0.0f;\r
-\r
-\r
-    /**\r
-     * Constructs a SioxSegmentator Object to be used for image segmentation.\r
-     *\r
-     * @param w X resolution of the image to be segmentated.\r
-     * @param h Y resolution of the image to be segmentated.\r
-     * @param limits Size of the cluster on LAB axises.\r
-     *        If <code>null</code>, the default value {0.64f,1.28f,2.56f}\r
-     *        is used.\r
-     */\r
-    SioxSegmentator(int w, int h, float *limitsArg, int limitsSize);\r
-\r
-    /**\r
-     * Destructor\r
-     */\r
-    virtual ~SioxSegmentator();\r
-\r
-\r
-    /**\r
-     * Segmentates the given image with information from the confidence\r
-     * matrix.\r
-     * <P>\r
-     * The confidence entries  of <code>BACKGROUND_CONFIDENCE</code> or less\r
-     * are mark known background pixel for the segmentation, those\r
-     * of at least <code>FOREGROUND_CONFIDENCE</code> mark known\r
-     * foreground pixel for the segmentation. Any other entry is treated\r
-     * as region of unknown affiliation.\r
-     * <P>\r
-     * As result, each pixel is classified either as foregroound or\r
-     * background, stored back into its <code>cm</code> entry as confidence\r
-     * <code>CERTAIN_FOREGROUND_CONFIDENCE</code> or\r
-     * <code>CERTAIN_BACKGROUND_CONFIDENCE</code>.\r
-     *\r
-     * @param image Pixel data of the image to be segmentated.\r
-     *        Every integer represents one ARGB-value.\r
-     * @param imageSize number of values in image\r
-     * @param cm Confidence matrix specifying the probability of an image\r
-     *        belonging to the foreground before and after the segmentation.\r
-     * @param smoothness Number of smoothing steps in the post processing.\r
-     * @param sizeFactorToKeep Segmentation retains the largest connected\r
-     *        foreground component plus any component with size at least\r
-     *        <CODE>sizeOfLargestComponent/sizeFactorToKeep</CODE>.\r
-     * @return <CODE>true</CODE> if the segmentation algorithm succeeded,\r
-     *         <CODE>false</CODE> if segmentation is impossible\r
-     */\r
-    bool segmentate(unsigned long *image, int imageSize,\r
-                    float *cm, int cmSize,\r
-                    int smoothness, double sizeFactorToKeep);\r
-\r
-    /**\r
-     * Clears given confidence matrix except entries for the largest connected\r
-     * component and every component with\r
-     * <CODE>size*sizeFactorToKeep >= sizeOfLargestComponent</CODE>.\r
-     *\r
-     * @param cm  Confidence matrix to be analysed\r
-     * @param threshold Pixel visibility threshold.\r
-     *        Exactly those cm entries larger than threshold are considered\r
-     *        to be a "visible" foreground pixel.\r
-     * @param sizeFactorToKeep This method keeps the largest connected\r
-     *        component plus any component with size at least\r
-     *        <CODE>sizeOfLargestComponent/sizeFactorToKeep</CODE>.\r
-     */\r
-    void keepOnlyLargeComponents(float *cm, int cmSize,\r
-                                 float threshold,\r
-                                 double sizeFactorToKeep);\r
-\r
-    /**\r
-     * Depth first search pixels in a foreground component.\r
-     *\r
-     * @param cm confidence matrix to be searched.\r
-     * @param i starting position as index to confidence matrix.\r
-     * @param threshold defines the minimum value at which a pixel is\r
-     *        considered foreground.\r
-     * @param curlabel label no of component.\r
-     * @return size in pixel of the component found.\r
-     */\r
-    int depthFirstSearch(float *cm, int i, float threshold, int curLabel);\r
-\r
-    /**\r
-     * Refines the classification stored in the confidence matrix by modifying\r
-     * the confidences for regions which have characteristics to both\r
-     * foreground and background if they fall into the specified square.\r
-     * <P>\r
-     * The can be used in displaying the image by assigning the alpha values\r
-     * of the pixels according to the confidence entries.\r
-     * <P>\r
-     * In the algorithm descriptions and examples GUIs this step is referrered\r
-     * to as <EM>Detail Refinement (Brush)</EM>.\r
-     *\r
-     * @param x Horizontal coordinate of the squares center.\r
-     * @param y Vertical coordinate of the squares center.\r
-     * @param brushmode Mode of the refinement applied, <CODE>ADD_EDGE</CODE>\r
-     *        or <CODE>SUB_EDGE</CODE>. Add mode only modifies pixels\r
-     *        formerly classified as background, sub mode only those\r
-     *        formerly classified as foreground.\r
-     * @param threshold Threshold for the add and sub refinement, deciding\r
-     *        at the confidence level to stop at.\r
-     * @param cf The confidence matrix to modify, generated by\r
-     *        <CODE>segmentate</CODE>, possibly already refined by privious\r
-     *        calls to <CODE>subpixelRefine</CODE>.\r
-     * @param brushsize Halfed diameter of the square shaped brush.\r
-     *\r
-     * @see #segmentate\r
-     */\r
-    void subpixelRefine(int x, int y, int brushmode,\r
-                             float threshold, float *cf, int brushsize);\r
-\r
-    /**\r
-     * Refines the classification stored in the confidence matrix by modifying\r
-     * the confidences for regions which have characteristics to both\r
-     * foreground and background if they fall into the specified area.\r
-     * <P>\r
-     * The can be used in displaying the image by assigning the alpha values\r
-     * of the pixels according to the confidence entries.\r
-     * <P>\r
-     * In the algorithm descriptions and examples GUIs this step is referrered\r
-     * to as <EM>Detail Refinement (Brush)</EM>.\r
-     *\r
-     * @param area Area in which the reworking of the segmentation is\r
-     *        applied to.\r
-     * @param brushmode Mode of the refinement applied, <CODE>ADD_EDGE</CODE>\r
-     *        or <CODE>SUB_EDGE</CODE>. Add mode only modifies pixels\r
-     *        formerly classified as background, sub mode only those\r
-     *        formerly classified as foreground.\r
-     * @param threshold Threshold for the add and sub refinement, deciding\r
-     *        at the confidence level to stop at.\r
-     * @param cf The confidence matrix to modify, generated by\r
-     *        <CODE>segmentate</CODE>, possibly already refined by privious\r
-     *        calls to <CODE>subpixelRefine</CODE>.\r
-     *\r
-     * @see #segmentate\r
-     */\r
-    bool subpixelRefine(int xa, int ya, int dx, int dy,\r
-                                     int brushmode,\r
-                                     float threshold, float *cf);\r
-    /**\r
-     * A region growing algorithms used to fill up the confidence matrix\r
-     * with <CODE>CERTAIN_FOREGROUND_CONFIDENCE</CODE> for corresponding\r
-     * areas of equal colors.\r
-     * <P>\r
-     * Basically, the method works like the <EM>Magic Wand<EM> with a\r
-     * tolerance threshold of zero.\r
-     *\r
-     * @param cm confidence matrix to be searched\r
-     * @param image image to be searched\r
-     */\r
-    void fillColorRegions(float *cm, int cmSize, unsigned long *image);\r
-\r
-private:\r
-\r
-    /**\r
-     * Prevent this from being used\r
-     */\r
-    SioxSegmentator();\r
-\r
-    /** error logging **/\r
-    void error(char *format, ...);\r
-\r
-    /** trace logging **/\r
-    void trace(char *format, ...);\r
-\r
-    typedef enum\r
-        {\r
-        ADD_EDGE, /** Add mode for the subpixel refinement. */\r
-        SUB_EDGE  /** Subtract mode for the subpixel refinement. */\r
-        } BrushMode;\r
-\r
-    // instance fields:\r
-\r
-    /** Horizontal resolution of the image to be segmentated. */\r
-    int imgWidth;\r
-\r
-    /** Vertical resolution of the image to be segmentated. */\r
-    int imgHeight;\r
-\r
-    /** Stores component label (index) by pixel it belongs to. */\r
-    int *labelField;\r
-\r
-    /**\r
-     * LAB color values of pixels that are definitly known background.\r
-     * Entries are of form {l,a,b}.\r
-     */\r
-    std::vector<CLAB> knownBg;\r
-\r
-    /**\r
-     * LAB color values of pixels that are definitly known foreground.\r
-     * Entries are of form {l,a,b}.\r
-     */\r
-    std::vector<CLAB> knownFg;\r
-\r
-    /** Holds background signature (a characteristic subset of the bg.) */\r
-    std::vector<CLAB> bgSignature;\r
-\r
-    /** Holds foreground signature (a characteristic subset of the fg).*/\r
-    std::vector<CLAB> fgSignature;\r
-\r
-    /** Size of cluster on lab axis. */\r
-    float *limits;\r
-\r
-    /** Maximum distance of two lab values. */\r
-    float clusterSize;\r
-\r
-    /**\r
-     * Stores Tupels for fast access to nearest background/foreground pixels.\r
-     */\r
-    std::map<unsigned long, Tupel> hs;\r
-\r
-    /** Size of the biggest blob.*/\r
-    int regionCount;\r
-\r
-    /** Copy of the original image, needed for detail refinement. */\r
-    long *origImage;\r
-    long origImageSize;\r
-\r
-    /** A flag that stores if the segmentation algorithm has already ran.*/\r
-    bool segmentated;\r
-\r
-};\r
-\r
-} //namespace siox\r
-} //namespace org\r
-\r
-#endif /* __SIOX_SEGMENTATOR_H__ */\r
-\r
+#ifndef __SIOX_SEGMENTATOR_H__
+#define __SIOX_SEGMENTATOR_H__
+/*
+   Copyright 2005, 2006 by Gerald Friedland, Kristian Jantz and Lars Knipping
+
+   Conversion to C++ for Inkscape by Bob Jamison
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+ */
+
+#include <map>
+#include <vector>
+
+namespace org
+{
+namespace siox
+{
+
+/**
+ * Image segmentator based on
+ *<em>SIOX: Simple Interactive Object Extraction</em>.
+ * <P>
+ * To segmentate an image one has to perform the following steps.
+ * <OL><LI>Construct an instance of <code>SioxSegmentator</code>.
+ * </LI><LI>Create a confidence matrix, where each entry marks its
+ *      corresponding image pixel to belong to the foreground, to the
+ *      background, or being of unknown type.
+ * </LI><LI>Call <code>segmentate</code> on the image with the confidence
+ *       matrix. This stores the result as new foreground confidence into
+ *       the confidence matrix, with each entry being either
+ *       zero (<code>CERTAIN_BACKGROUND_CONFIDENCE</code>) or one
+ *       (<code>CERTAIN_FOREGROUND_CONFIDENCE</code>).
+ * </LI><LI>Optionally call <code>subpixelRefine</code> to areas
+ *      where pixels contain both foreground and background (e.g.
+ *      object borders or highly detailed features like flowing hairs).
+ *      The pixel are then assigned confidence values bwetween zero and
+ *      one to give them a measure of "foregroundness".
+ *      This step may be repeated as often as needed.
+ * </LI></OL>
+ * <P>
+ * For algorithm documentation refer to
+ * G. Friedland, K. Jantz, L. Knipping, R. Rojas:<i>
+ * Image Segmentation by Uniform Color Clustering
+ *  -- Approach and Benchmark Results</i>,
+ * <A HREF="http://www.inf.fu-berlin.de/inst/pubs/tr-b-05-07.pdf">Technical Report B-05-07</A>,
+ * Department of Computer Science, Freie Universitaet Berlin, June 2005.<br>
+ * <P>
+ * See <A HREF="http://www.siox.org/" target="_new">http://www.siox.org</A> for more information.<br>
+ * <P>
+ * Algorithm idea by Gerald Friedland.
+ *
+ * @author Gerald Friedland, Kristian Jantz, Lars Knipping
+ * @version 1.12
+ */
+
+/**
+ * Helper class for storing the minimum distances to a cluster centroid
+ * in background and foreground and the index to the centroids in each
+ * signature for a given color.
+ */
+class Tupel {
+public:
+
+    Tupel()
+        {
+        minBgDist  = 0.0f;
+        indexMinBg = 0;
+        minFgDist  = 0.0f;
+        indexMinFg = 0;
+        }
+    Tupel(float minBgDistArg, long indexMinBgArg,
+          float minFgDistArg, long indexMinFgArg)
+        {
+       minBgDist  = minBgDistArg;
+       indexMinBg = indexMinBgArg;
+       minFgDist  = minFgDistArg;
+       indexMinFg = indexMinFgArg;
+        }
+    Tupel(const Tupel &other)
+        {
+       minBgDist  = other.minBgDist;
+       indexMinBg = other.indexMinBg;
+       minFgDist  = other.minFgDist;
+       indexMinFg = other.indexMinFg;
+        }
+    Tupel &operator=(const Tupel &other)
+        {
+       minBgDist  = other.minBgDist;
+       indexMinBg = other.indexMinBg;
+       minFgDist  = other.minFgDist;
+       indexMinFg = other.indexMinFg;
+       return *this;
+        }
+    virtual ~Tupel()
+        {}
+
+    float minBgDist;
+    long  indexMinBg;
+    float minFgDist;
+    long  indexMinFg;
+
+ };
+
+
+class CLAB
+{
+public:
+    CLAB()
+        {
+        C = L = A = B = 0.0f;
+        }
+    CLAB(float lArg, float aArg, float bArg)
+        {
+        C = 0.0f;
+        L = lArg;
+        A = aArg;
+        B = bArg;
+        }
+    CLAB(const CLAB &other)
+        {
+        C = other.C;
+        L = other.L;
+        A = other.A;
+        B = other.B;
+        }
+    CLAB &operator=(const CLAB &other)
+        {
+        C = other.C;
+        L = other.L;
+        A = other.A;
+        B = other.B;
+        return *this;
+        }
+    virtual ~CLAB()
+        {}
+
+    float C;
+    float L;
+    float A;
+    float B;
+};
+
+
+class SioxSegmentator
+{
+public:
+
+    /** Confidence corresponding to a certain foreground region (equals one). */
+    static const float CERTAIN_FOREGROUND_CONFIDENCE;  //=1.0f;
+
+    /** Confidence for a region likely being foreground.*/
+    static const float FOREGROUND_CONFIDENCE;  //=0.8f;
+
+    /** Confidence for foreground or background type being equally likely.*/
+    static const float UNKNOWN_REGION_CONFIDENCE;  //=0.5f;
+
+    /** Confidence for a region likely being background.*/
+    static const float BACKGROUND_CONFIDENCE;  //=0.1f;
+
+    /** Confidence corresponding to a certain background reagion (equals zero). */
+    static const float CERTAIN_BACKGROUND_CONFIDENCE;  //=0.0f;
+
+
+    /**
+     * Constructs a SioxSegmentator Object to be used for image segmentation.
+     *
+     * @param w X resolution of the image to be segmentated.
+     * @param h Y resolution of the image to be segmentated.
+     * @param limits Size of the cluster on LAB axises.
+     *        If <code>null</code>, the default value {0.64f,1.28f,2.56f}
+     *        is used.
+     */
+    SioxSegmentator(int w, int h, float *limitsArg, int limitsSize);
+
+    /**
+     * Destructor
+     */
+    virtual ~SioxSegmentator();
+
+
+    /**
+     * Segmentates the given image with information from the confidence
+     * matrix.
+     * <P>
+     * The confidence entries  of <code>BACKGROUND_CONFIDENCE</code> or less
+     * are mark known background pixel for the segmentation, those
+     * of at least <code>FOREGROUND_CONFIDENCE</code> mark known
+     * foreground pixel for the segmentation. Any other entry is treated
+     * as region of unknown affiliation.
+     * <P>
+     * As result, each pixel is classified either as foregroound or
+     * background, stored back into its <code>cm</code> entry as confidence
+     * <code>CERTAIN_FOREGROUND_CONFIDENCE</code> or
+     * <code>CERTAIN_BACKGROUND_CONFIDENCE</code>.
+     *
+     * @param image Pixel data of the image to be segmentated.
+     *        Every integer represents one ARGB-value.
+     * @param imageSize number of values in image
+     * @param cm Confidence matrix specifying the probability of an image
+     *        belonging to the foreground before and after the segmentation.
+     * @param smoothness Number of smoothing steps in the post processing.
+     * @param sizeFactorToKeep Segmentation retains the largest connected
+     *        foreground component plus any component with size at least
+     *        <CODE>sizeOfLargestComponent/sizeFactorToKeep</CODE>.
+     * @return <CODE>true</CODE> if the segmentation algorithm succeeded,
+     *         <CODE>false</CODE> if segmentation is impossible
+     */
+    bool segmentate(unsigned long *image, int imageSize,
+                    float *cm, int cmSize,
+                    int smoothness, double sizeFactorToKeep);
+
+    /**
+     * Clears given confidence matrix except entries for the largest connected
+     * component and every component with
+     * <CODE>size*sizeFactorToKeep >= sizeOfLargestComponent</CODE>.
+     *
+     * @param cm  Confidence matrix to be analysed
+     * @param threshold Pixel visibility threshold.
+     *        Exactly those cm entries larger than threshold are considered
+     *        to be a "visible" foreground pixel.
+     * @param sizeFactorToKeep This method keeps the largest connected
+     *        component plus any component with size at least
+     *        <CODE>sizeOfLargestComponent/sizeFactorToKeep</CODE>.
+     */
+    void keepOnlyLargeComponents(float *cm, int cmSize,
+                                 float threshold,
+                                 double sizeFactorToKeep);
+
+    /**
+     * Depth first search pixels in a foreground component.
+     *
+     * @param cm confidence matrix to be searched.
+     * @param i starting position as index to confidence matrix.
+     * @param threshold defines the minimum value at which a pixel is
+     *        considered foreground.
+     * @param curlabel label no of component.
+     * @return size in pixel of the component found.
+     */
+    int depthFirstSearch(float *cm, int i, float threshold, int curLabel);
+
+    /**
+     * Refines the classification stored in the confidence matrix by modifying
+     * the confidences for regions which have characteristics to both
+     * foreground and background if they fall into the specified square.
+     * <P>
+     * The can be used in displaying the image by assigning the alpha values
+     * of the pixels according to the confidence entries.
+     * <P>
+     * In the algorithm descriptions and examples GUIs this step is referrered
+     * to as <EM>Detail Refinement (Brush)</EM>.
+     *
+     * @param x Horizontal coordinate of the squares center.
+     * @param y Vertical coordinate of the squares center.
+     * @param brushmode Mode of the refinement applied, <CODE>ADD_EDGE</CODE>
+     *        or <CODE>SUB_EDGE</CODE>. Add mode only modifies pixels
+     *        formerly classified as background, sub mode only those
+     *        formerly classified as foreground.
+     * @param threshold Threshold for the add and sub refinement, deciding
+     *        at the confidence level to stop at.
+     * @param cf The confidence matrix to modify, generated by
+     *        <CODE>segmentate</CODE>, possibly already refined by privious
+     *        calls to <CODE>subpixelRefine</CODE>.
+     * @param brushsize Halfed diameter of the square shaped brush.
+     *
+     * @see #segmentate
+     */
+    void subpixelRefine(int x, int y, int brushmode,
+                             float threshold, float *cf, int brushsize);
+
+    /**
+     * Refines the classification stored in the confidence matrix by modifying
+     * the confidences for regions which have characteristics to both
+     * foreground and background if they fall into the specified area.
+     * <P>
+     * The can be used in displaying the image by assigning the alpha values
+     * of the pixels according to the confidence entries.
+     * <P>
+     * In the algorithm descriptions and examples GUIs this step is referrered
+     * to as <EM>Detail Refinement (Brush)</EM>.
+     *
+     * @param area Area in which the reworking of the segmentation is
+     *        applied to.
+     * @param brushmode Mode of the refinement applied, <CODE>ADD_EDGE</CODE>
+     *        or <CODE>SUB_EDGE</CODE>. Add mode only modifies pixels
+     *        formerly classified as background, sub mode only those
+     *        formerly classified as foreground.
+     * @param threshold Threshold for the add and sub refinement, deciding
+     *        at the confidence level to stop at.
+     * @param cf The confidence matrix to modify, generated by
+     *        <CODE>segmentate</CODE>, possibly already refined by privious
+     *        calls to <CODE>subpixelRefine</CODE>.
+     *
+     * @see #segmentate
+     */
+    bool subpixelRefine(int xa, int ya, int dx, int dy,
+                                     int brushmode,
+                                     float threshold, float *cf);
+    /**
+     * A region growing algorithms used to fill up the confidence matrix
+     * with <CODE>CERTAIN_FOREGROUND_CONFIDENCE</CODE> for corresponding
+     * areas of equal colors.
+     * <P>
+     * Basically, the method works like the <EM>Magic Wand<EM> with a
+     * tolerance threshold of zero.
+     *
+     * @param cm confidence matrix to be searched
+     * @param image image to be searched
+     */
+    void fillColorRegions(float *cm, int cmSize, unsigned long *image);
+
+private:
+
+    /**
+     * Prevent this from being used
+     */
+    SioxSegmentator();
+
+    /** error logging **/
+    void error(char *format, ...);
+
+    /** trace logging **/
+    void trace(char *format, ...);
+
+    typedef enum
+        {
+        ADD_EDGE, /** Add mode for the subpixel refinement. */
+        SUB_EDGE  /** Subtract mode for the subpixel refinement. */
+        } BrushMode;
+
+    // instance fields:
+
+    /** Horizontal resolution of the image to be segmentated. */
+    int imgWidth;
+
+    /** Vertical resolution of the image to be segmentated. */
+    int imgHeight;
+
+    /** Stores component label (index) by pixel it belongs to. */
+    int *labelField;
+
+    /**
+     * LAB color values of pixels that are definitly known background.
+     * Entries are of form {l,a,b}.
+     */
+    std::vector<CLAB> knownBg;
+
+    /**
+     * LAB color values of pixels that are definitly known foreground.
+     * Entries are of form {l,a,b}.
+     */
+    std::vector<CLAB> knownFg;
+
+    /** Holds background signature (a characteristic subset of the bg.) */
+    std::vector<CLAB> bgSignature;
+
+    /** Holds foreground signature (a characteristic subset of the fg).*/
+    std::vector<CLAB> fgSignature;
+
+    /** Size of cluster on lab axis. */
+    float *limits;
+
+    /** Maximum distance of two lab values. */
+    float clusterSize;
+
+    /**
+     * Stores Tupels for fast access to nearest background/foreground pixels.
+     */
+    std::map<unsigned long, Tupel> hs;
+
+    /** Size of the biggest blob.*/
+    int regionCount;
+
+    /** Copy of the original image, needed for detail refinement. */
+    long *origImage;
+    long origImageSize;
+
+    /** A flag that stores if the segmentation algorithm has already ran.*/
+    bool segmentated;
+
+};
+
+} //namespace siox
+} //namespace org
+
+#endif /* __SIOX_SEGMENTATOR_H__ */
+