segment_sct_tool.h

Go to the documentation of this file.

#ifndef SEGMENT_SCT_TOOL_H
#define SEGMENT_SCT_TOOL_H

#include <cmath>
#include <iostream>
#include <fstream>
#include <values.h>
#include <boost/numeric/ublas/matrix.hpp>
#include "object.h"
#include "image.h"
#include "rgba.h"

namespace mimas {
  class segment_sct_tool: public object
  {
    public:
      typedef boost::numeric::ublas::matrix< double > Matrix;

    private:
      int angsplitA, angsplitB;

    public:
      segment_sct_tool(void); 
      void segment(const image< rgba< unsigned char > > &imagein, image< rgba< unsigned char > > &imageout); 
      void setSplitA(int sa); 
      void setSplitB(int sb); 


  };

  segment_sct_tool::segment_sct_tool(void)
  {
    angsplitA=angsplitB=2; // set some initial values
  }
  
  void segment_sct_tool::setSplitA(int sa)
  {
    angsplitA=sa;
  }

  void segment_sct_tool::setSplitB(int sb)
  {
    angsplitB=sb;
  }

  void segment_sct_tool::segment(const image< rgba< unsigned char > > &imagein, image< rgba< unsigned char > > &imageout)
  {
    image<int> imagetemp;
    int w=imagein.getWidth();
    int h=imagein.getHeight();
    double l;
    Matrix angA(h,w);
    Matrix angB(h,w);
    double minA,maxA,minB,maxB;


    if (imageout.initialised())
    {
      if ((imageout.getWidth()!=imagein.getWidth()) || (imageout.getHeight()!=imagein.getHeight()))
        imageout.clear();
    }

    if (!imageout.initialised())
      imageout.init(w,h);

    imagetemp.init(w,h);


    minA=MAXDOUBLE;
    minB=MAXDOUBLE;
    maxA=-MAXDOUBLE;
    maxB=-MAXDOUBLE;

    for (int j=0; j<h; j++)
      for (int i=0; i<w; i++)
      {
        const rgba< unsigned char > *pixel = &imagein.getPixel( i,j );
        double r = (double)pixel->getRed();
        double g = (double)pixel->getGreen();
        double b = (double)pixel->getBlue();

        l=sqrt (r*r + g*g + b*b);

        angA(j,i)=acos(b/l);
        angB(j,i)=acos(r/(l*sin(angA(j,i))));

        if (angA(j,i) > maxA) maxA=angA(j,i);
        if (angB(j,i) > maxB) maxB=angB(j,i);
        if (angA(j,i) < minA) minA=angA(j,i);
        if (angB(j,i) < minB) minB=angB(j,i);

        imagetemp.setPixel(i,j,0);

      }

    int checkA=0, checkB=0, segcount=0;
    for (double sa=minA; sa<maxA; sa+=(maxA-minA)/angsplitA)
    {
      checkA++;
      if (checkA>angsplitA) continue; // for rounding errors

      checkB=0;
      for (double sb=minB; sb<maxB; sb+=(maxB-minB)/angsplitB)
      {
        checkB++;
        if (checkB>angsplitB) continue; // for rounding errors

        // label!
        for (int j=0; j<h; j++)
          for (int i=0; i<w; i++)
            if ((angA(j,i)>=sa) && (angB(j,i)>=sb))
              imagetemp.setPixel(i,j,segcount);

        segcount++;

      }
    }

    int aveR[angsplitA*angsplitB];
    int aveG[angsplitA*angsplitB];
    int aveB[angsplitA*angsplitB];

    // Two passes :(
    for (segcount=0; segcount<angsplitA*angsplitB; segcount++)
    {
      int counter=0;
      aveR[segcount]=0;
      aveG[segcount]=0;
      aveB[segcount]=0;

      for (int j=0; j<h; j++)
        for (int i=0; i<w; i++)
          if (imagetemp.getPixel(i,j)==segcount)
          {
            const rgba< unsigned char > *pixel = &imagein.getPixel( i,j );
            int r = pixel->getRed();
            int g = pixel->getGreen();
            int b = pixel->getBlue();

            aveR[segcount]+=r;
            aveG[segcount]+=g;
            aveB[segcount]+=b;
            counter++;
          }

      if (counter==0) continue;

      aveR[segcount]=aveR[segcount]/counter;
      aveG[segcount]=aveG[segcount]/counter;
      aveB[segcount]=aveB[segcount]/counter;
    }

    for (segcount=0; segcount<angsplitA*angsplitB; segcount++)
    {
      for (int j=0; j<h; j++)
        for (int i=0; i<w; i++)
          if (imagetemp.getPixel(i,j)==segcount)
          {
            rgba<int> pixcol;
            pixcol.setRed(aveR[segcount]);
            pixcol.setGreen(aveG[segcount]);
            pixcol.setBlue(aveB[segcount]);
            imageout.setPixel(i,j,pixcol);
          }
    }

#ifndef NDEBUG
    std::cerr << std::endl << minA << std::endl;
    std::cerr << maxA << std::endl;
    std::cerr << minB << std::endl;
    std::cerr << maxB << std::endl;
    std::cerr << checkA << std::endl;
    std::cerr << checkB << std::endl;
    std::cerr << segcount << std::endl;
#endif

  }

}

#endif

---