Label.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#ifndef __Label_HH__
#define __Label_HH__

#include <bias_config.h>

#include <vector>
#include <map>
#include <new>

#include <Base/Debug/Debug.hh>
#include <Base/Image/Image.hh>
#include <Base/Math/Vector2.hh>
#include "FilterBase.hh"

#define LABEL_STORAGE_TYPE ImageBase::ST_int
#define LABEL_CALC_TYPE int
#define D_INIT        0x0001
#define D_LABEL       0x0002


namespace BIAS
{
  // for sorting SortVec_
  class /*BIASFilter_EXPORT*/ CCAStruct {
  public:
    CCAStruct() {};
    CCAStruct(const CCAStruct& s){
      bc=s.bc; tl=s.tl; br=s.br; center=s.center; x=s.x; y=s.y; }

    int bc; ///< blob count = number of pixesl in blob
    BIAS::Vector2<int> tl, br; // bounding box of blob
    BIAS::Vector2<double> center; // blob center 
    std::vector<int> x, y; // for median computation

    CCAStruct& operator=(const CCAStruct& s) {
      bc=s.bc; tl=s.tl; br=s.br; center= s.center; x=s.x; y=s.y;return *this; }
    bool operator<(const CCAStruct &right) const {
      return bc>right.bc; };
    bool operator==(const CCAStruct &right) const {
      return bc==right.bc; };
  };
  

  /** @class Label
      @ingroup g_filter
      @brief does a connected component analysis and labels all connected 
      regions
      
      there is no difference between fore and background. Each region that
      has a different color than all its neighbouring pixels is its own region.
      Each pixel is assigned to one region.
      
      There are utility functions to get Blobcounts and bounding boxes.
      So far only 4neighborhoud and grey value images only.
      Important: When using Filter(), the resulting image is only valid
      if there are less than 255 regions!!
      @author woelk
  */
  class BIASFilter_EXPORT Label 
    : public BIAS::FilterBase<unsigned char, unsigned char>
  {
  public:
    Label();
    ~Label();
       
    /** call this if you don't need the output image, is faster than Filter
     */
    int Process(const Image<unsigned char>& im);

    virtual int Filter(const Image<unsigned char>& src, 
                       Image<unsigned char>& dst);

    /** labels an unsigned short int using an 4er neighbourhood and
        returns it in DestinationImage
        if DestinationImage is allocated it is not reallocated 
        @status untested 
        @author Felix Woelk
    */
    int Label4Neighbour(const BIAS::Image<unsigned char>& Image, 
                        BIAS::Image<unsigned char>& DestinationImage);



    /** labels an unsigned short int using an 4er neighbourhood and
        returns it in DestinationImage
        if DestinationImage is allocated it is not reallocated */
    int Label4Neighbour(const BIAS::Image<LABEL_CALC_TYPE>& Image, 
                        BIAS::Image<LABEL_CALC_TYPE>& DestinationImage);    

    /** returns a list with the size of each blob, largest first,
        if no blobs are found a list with a single 0 is returned      
        @author Daniel Grest, Aug. 2004
    */
    inline std::vector<int> GetBlobCounts()
    { return BlobCount_; }

    /** Returns a map that hold the blob size for each label. */
    inline std::map<unsigned char, int> GetBlobMap()
    { return BlobMap_; }

    /** returns in li the image where each region has a different grey value,
        value zero is the background region
     */
    inline void GetLabelImage(Image<LABEL_CALC_TYPE> &li)
    { li=LabelResultImage_; }

    /** returns two lists,one with the topLeft coordinates of the 
        bounding boxes of each region and one with the botrights, 
        sorted by size of regions  (in pixel)
        @return 0, in case of no error
        @author woelk
    */
    inline
      int GetBoundingBoxes(std::vector<BIAS::Vector2<int> >& topLefts,
      std::vector<BIAS::Vector2<int> >& botRights)
    { topLefts = TopLefts_; botRights = BotRights_; return 0; };

    /** @brief returns the centers of the blobs
        @author woelk 03/2006 */
    inline void GetCenters(std::vector<BIAS::Vector2<double> >& centers) const
    { centers = Centers_; }

    /** @brief returns the median centers of the blobs
        @author woelk 03/2006 */
    inline void GetMedianCenters(std::vector<BIAS::Vector2<double> >&cts) const
    { cts = MedianCenters_; }

    inline void GetBlobSizes(std::vector<int>& sizes) const
    { sizes = BlobCount_; }

  protected:
   
    // protecteds for Label filter 
    bool LabelInitialized_;
    Image<LABEL_CALC_TYPE> LabelSumImage_;
    Image<LABEL_CALC_TYPE> LabelResultImage_;
    void LabelInit_(const ImageBase& Image);  
    void LabelRelease_();
    int Label4Neighbour_();
    
    // for CCA funxtionality
    std::vector<int> Num_;    
    std::vector<BIAS::CCAStruct> SortVec_;

    std::vector<int> BlobCount_;
    std::vector<BIAS::Vector2<int> > TopLefts_, BotRights_;
    std::vector<BIAS::Vector2<double> > Centers_; 
    std::vector<BIAS::Vector2<double> > MedianCenters_; 

    virtual void GetBordersValid_(int& border_x, int& border_y) const;

private: // avoid DLL export
  std::map<unsigned char,int> BlobMap_;
  }; 

} // namespace

#endif // __FILTER_HH__