SLICO.h

// SLICO.h: interface for the SLICO class.
//===========================================================================
// This code implements the zero parameter superpixel segmentation technique
// described in:
//
//
//
// "SLIC Superpixels Compared to State-of-the-art Superpixel Methods"
//
// Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua,
// and Sabine Susstrunk,
//
// IEEE TPAMI, Volume 34, Issue 11, Pages 2274-2282, November 2012.
//
//
//===========================================================================
// Copyright (c) 2013 Radhakrishna Achanta.
//
// For commercial use please contact the author:
//
// Email: firstname.lastname@epfl.ch
//===========================================================================

#ifndef _SLICO_H_INCLUDED_
#define _SLICO_H_INCLUDED_


#include <vector>
#include <string>
#include <algorithm>
using namespace std;


class SLICO
{
public:
    SLICO();
    virtual ~SLICO();
    //============================================================================
    // Superpixel segmentation for a given step size (superpixel size ~= step*step)
    //============================================================================
    void PerformSLICO_ForGivenStepSize(
        const unsigned char*        ubuff,//Each 32 bit unsigned int contains ARGB pixel values.
        const int                   width,
        const int                   height,
        int*                        klabels,
        int&                        numlabels,
        const int&                  STEP,
        const double&               m);
    //============================================================================
    // Superpixel segmentation for a given number of superpixels
    //============================================================================
    void PerformSLICO_ForGivenK(
        const unsigned char*        ubuff,//Each 32 bit unsigned int contains ARGB pixel values.
        const int                   width,
        const int                   height,
        int*                        klabels,
        int&                        numlabels,
        const int&                  K);

    //============================================================================
    // Save superpixel labels in a text file in raster scan order
    //============================================================================
    /*void SaveSuperpixelLabels(
        const int*                  labels,
        const int&                  width,
        const int&                  height,
        const string&               filename,
        const string&               path);*/
    //============================================================================
    // Function to draw boundaries around superpixels of a given 'color'.
    // Can also be used to draw boundaries around supervoxels, i.e layer by layer.
    //============================================================================
    void DrawContoursAroundSegments(
        unsigned char*              segmentedImage,
        const int*                  labels,
        const int&                  width,
        const int&                  height);

    void DrawContoursAroundSegmentsTwoColors(
        unsigned char*              ubuff,
        const int*                  labels,
        const int&                  width,
        const int&                  height);

private:

    //============================================================================
    // Magic SLIC. No need to set M (compactness factor) and S (step size).
    // SLICO (SLIC Zero) varies only M dynamicaly, not S.
    //============================================================================
    void PerformSuperpixelSegmentation_VariableSandM(
        vector<double>&             kseedsl,
        vector<double>&             kseedsa,
        vector<double>&             kseedsb,
        vector<double>&             kseedsx,
        vector<double>&             kseedsy,
        int*                        klabels,
        const int&                  STEP,
        const int&                  NUMITR);
    //============================================================================
    // Pick seeds for superpixels when step size of superpixels is given.
    //============================================================================
    void GetLABXYSeeds_ForGivenStepSize(
        vector<double>&             kseedsl,
        vector<double>&             kseedsa,
        vector<double>&             kseedsb,
        vector<double>&             kseedsx,
        vector<double>&             kseedsy,
        const int&                  STEP,
        const bool&                 perturbseeds,
        const vector<double>&       edgemag);
    //============================================================================
    // Pick seeds for superpixels when number of superpixels is input.
    //============================================================================
    void GetLABXYSeeds_ForGivenK(
        vector<double>&             kseedsl,
        vector<double>&             kseedsa,
        vector<double>&             kseedsb,
        vector<double>&             kseedsx,
        vector<double>&             kseedsy,
        const int&                  STEP,
        const bool&                 perturbseeds,
        const vector<double>&       edges);

    //============================================================================
    // Move the seeds to low gradient positions to avoid putting seeds at region boundaries.
    //============================================================================
    void PerturbSeeds(
        vector<double>&             kseedsl,
        vector<double>&             kseedsa,
        vector<double>&             kseedsb,
        vector<double>&             kseedsx,
        vector<double>&             kseedsy,
        const vector<double>&       edges);
    //============================================================================
    // Detect color edges, to help PerturbSeeds()
    //============================================================================
    void DetectLabEdges(
        const double*               lvec,
        const double*               avec,
        const double*               bvec,
        const int&                  width,
        const int&                  height,
        vector<double>&             edges);
    //============================================================================
    // xRGB to XYZ conversion; helper for RGB2LAB()
    //============================================================================
    void RGB2XYZ(
        const unsigned char&        sR,
        const unsigned char&        sG,
        const unsigned char&        sB,
        double&                     X,
        double&                     Y,
        double&                     Z);
    //============================================================================
    // sRGB to CIELAB conversion
    //============================================================================
    void RGB2LAB(
        const unsigned char&        sR,
        const unsigned char&        sG,
        const unsigned char&        sB,
        double&                     lval,
        double&                     aval,
        double&                     bval);
    //============================================================================
    // sRGB to CIELAB conversion for 2-D images
    //============================================================================
    void DoRGBtoLABConversion(
        const unsigned char*&       ubuff,
        double*&                    lvec,
        double*&                    avec,
        double*&                    bvec);
    //============================================================================
    // sRGB to CIELAB conversion for 3-D volumes
    //============================================================================
    void DoRGBtoLABConversion(
        const unsigned char**&      ubuff,
        double**&                   lvec,
        double**&                   avec,
        double**&                   bvec);

    //============================================================================
    // Post-processing of SLIC segmentation, to avoid stray labels.
    //============================================================================
    void EnforceLabelConnectivity(
        const int*                  labels,
        const int&                  width,
        const int&                  height,
        int*                        nlabels,//input labels that need to be corrected to remove stray labels
        int&                        numlabels,//the number of labels changes in the end if segments are removed
        const int&                  K); //the number of superpixels desired by the user


private:
    int                                     m_width;
    int                                     m_height;
    int                                     m_depth;

    double*                                 m_lvec;
    double*                                 m_avec;
    double*                                 m_bvec;

    double**                                m_lvecvec;
    double**                                m_avecvec;
    double**                                m_bvecvec;
};

#endif // _SLICO_H_INCLUDED_