region.cc

来自「用于计算矩阵的特征值,及矩阵的其他运算.可以用与稀疏矩阵」· CC 代码 · 共 597 行 · 第 1/2 页

      }

      Util::Message::startBlock("brightness histogram computation"); 
      computeBrightnessHistograms();
      Util::Message::endBlock();

      Util::Message::endBlock();

      m_initialized = true;
  }


  //////////////////////////////////////////////////////////////////////////////
  //
  // patch classifier.  parameters are fit with default 
  //

  //color images
  static const float bp_stdev = 0.151709;
  static const float tp_stdev = 0.0875824;
  static const float cp_stdev = 0.225726;
  float cpss_model(const Util::Array1D<float> features)
  {
    float val = 0.85422;
    val += features(0) / bp_stdev * -0.105818; /* bp0 */
    val += features(1) / tp_stdev * -1.02351;  /* tp0 */
    val += features(2) / cp_stdev * -0.268088; /* cp0 */
    float post = 1.0 / (1.0 + exp(-val));
    if (!finite(post)) { return 0; }
    post = Util::minmax(0.0f,post,1.0f);
    return post;
  }

  //grayscale
  float gpss_model(const Util::Array1D<float> features)
  {
    float val = 2.14297;
    val += features(0) / bp_stdev * -1.0145;   /* bp0 */
    val += features(1) / tp_stdev * -1.34457;  /* tp0 */
    float post = 1.0 / (1.0 + exp(-val));
    if (!finite(post)) { return 0; }
    post = Util::minmax(0.0f,post,1.0f);
    return post;
  }

  float Region::getPss(const int scale, const int x1, const int y1, const int x2, const int y2) const
  {
    assert(m_initialized);
    float pval = 0;
    if (m_useColor)
    {
      Util::Array1D<float> features(3);
      features(0) = getBSim(scale,x1,y1,x2,y2);
      features(1) = getTSim(scale,x1,y1,x2,y2);
      features(2) = getCSim(scale,x1,y1,x2,y2);
      pval = cpss_model(features);
    }
    else
    {
      Util::Array1D<float> features(2);
      features(0) = getBSim(scale,x1,y1,x2,y2);
      features(1) = getTSim(scale,x1,y1,x2,y2);
      pval = gpss_model(features);
    }
    return pval;
  }


  //////////////////////////////////////////////////////////////////////////
  //
  // access histograms computed for the image.
  // 

  const Histogram& Region::getTextonHist(const int scale) const
  {
    assert(m_initialized);
    assert(scale >= 0 && scale < config.tpNumScales);
    return m_textonHist(scale);
  }
  const Histogram& Region::getLHist(const int scale) const
  {
    assert(m_initialized);
    assert(scale >= 0 && scale < config.bpNumScales);
    return m_lHist(scale);
  }
  const Histogram& Region::getAHist(const int scale) const
  {
    assert(m_initialized);
    assert(scale >= 0 && scale < config.cpNumScales);
    return m_aHist(scale);
  }
  const Histogram& Region::getBHist(const int scale) const
  {
    assert(m_initialized);
    assert(scale >= 0 && scale < config.cpNumScales);
    return m_bHist(scale);
  }


  //////////////////////////////////////////////////////////////////////////
  //
  // access similarities computed for the image.
  // 

  float Region::getTSim(const int scale, const int x1, const int y1, const int x2, const int y2) const
  {
    assert(m_initialized);
    float similarity = 0;
    textureSimilarity(m_textonHist(scale),x1,y1,x2,y2,similarity);
    return similarity;
  }

  float Region::getBSim(const int scale, const int x1, const int y1, const int x2, const int y2) const
  {
    assert(m_initialized);
    float similarity = 0;
    colorSimilarity(m_lHist(scale),x1,y1,x2,y2,similarity);    
    return similarity;
  }

  float Region::getCSim(const int scale, const int x1, const int y1, const int x2, const int y2) const
  {
    assert(m_initialized);
    float sa = 0;
    float sb = 0;    
    colorSimilarity(m_aHist(scale),x1,y1,x2,y2,sa);    
    colorSimilarity(m_bHist(scale),x1,y1,x2,y2,sb);    
    return 0.5 * (sa + sb);
  }


  //////////////////////////////////////////////////////////////////////////
  //
  // hints for accessing TSim,BSim,CSim
  //
  int Region::getTPNumScales() const
  {
    return config.tpNumScales;
  }

  int Region::getBPNumScales() const
  {
    return config.bpNumScales;
  }

  int Region::getCPNumScales() const
  {
    return config.cpNumScales;
  }

  
  //////////////////////////////////////////////////////////////////////////
 
  bool Region::useColor() const
  {
    assert(m_initialized);
    return m_useColor;    
  }
  
  //////////////////////////////////////////////////////////////////////////

  void
  Region::computeTextonHistograms()
  {
    m_textonHist.resize(config.tpNumScales);
    for (int scale = 0; scale < config.tpNumScales; scale++)
    {
        float filtStartScale = m_idiag * config.tpFiltStartScale;
        if (config.tpScaleLinked)
        {
          filtStartScale *= pow (config.tpScaleFactor, scale);
        }
     
        // create the filterbank
        FilterBank fbank(config.tpFiltNumOrient, config.tpFiltNumScales,
                         filtStartScale, config.tpFiltScaleFactor);

        Util::Message::debug(Util::String("Filterbank %d %d %f %f",
           config.tpFiltNumOrient,config.tpFiltNumScales, filtStartScale,config.tpFiltScaleFactor),2);

        //extract textons
        TextonMap textons;
        textons.map.resize(m_lab.size(1),m_lab.size(2));
        textons.numChannels = 0;

        if(config.textonFile == "")
        {
          const int nchannels = (int)rint(config.textonStartChannels*pow(config.textonChannelFactor,scale));
          computeTextons(*m_lab.slice(Util::LAB_L),fbank,nchannels,textons);
        }
        else
        {
          computeTextons(*m_lab.slice(Util::LAB_L),fbank,config.textonFile,textons);
        }
        Util::Message::debug(Util::String("Used %d textons",textons.numChannels),2);

        //now compute histograms
        const float tpScaleVal = m_idiag * config.tpStartScale * pow (config.tpScaleFactor, scale);
        m_textonHist(scale).resize(m_width,m_height,textons.numChannels);
        Group::computeTextonHistograms(textons,tpScaleVal,m_textonHist(scale)); 
    } 
  }  

  void
  Region::computeColorHistograms ()
  {
    m_aHist.resize(config.cpNumScales);
    m_bHist.resize(config.cpNumScales);

    // compute TP at each scale
    for (int scale = 0; scale < config.cpNumScales; scale++)
    {
      const float cpScaleVal = m_idiag * config.cpStartScale * pow (config.cpScaleFactor, scale);
      m_aHist(scale).resize(m_width,m_height,config.cpBinsA);
      m_bHist(scale).resize(m_width,m_height,config.cpBinsB);
      Group::computeColorHistograms(*m_lab.slice(Util::LAB_A), config.cpBinsA, cpScaleVal, config.cpSigma,
                                                config.cpSupport, config.cpZoom, m_aHist(scale));
      Group::computeColorHistograms(*m_lab.slice(Util::LAB_B), config.cpBinsB, cpScaleVal, config.cpSigma,
                                                config.cpSupport, config.cpZoom, m_bHist(scale));
    }
  }



  void
  Region::computeBrightnessHistograms ()
  {
      m_lHist.resize(config.bpNumScales);
      for (int scale = 0; scale < config.bpNumScales; scale++)
      {
        const float bpScaleVal = m_idiag * config.bpStartScale * pow (config.bpScaleFactor, scale);
        m_lHist(scale).resize(m_width,m_height,config.bpBinsL);
        Group::computeColorHistograms(*m_lab.slice(Util::LAB_L), config.bpBinsL, bpScaleVal, config.bpSigma,
                                        config.bpSupport, config.bpZoom, m_lHist(scale));
      }
  }


  ///////////////////////////////////////////////////////////////////////////
  
  void
  Region::computeTextonHistograms(const SupportMap& support)
  {
    m_textonHist.resize(1);
    float filtStartScale = m_idiag * config.tpFiltStartScale;
     
    // create the filterbank
    FilterBank fbank(config.tpFiltNumOrient, config.tpFiltNumScales,
                     filtStartScale, config.tpFiltScaleFactor);

    Util::Message::debug(Util::String("Filterbank %d %d %f %f",
       config.tpFiltNumOrient,config.tpFiltNumScales, filtStartScale,config.tpFiltScaleFactor),2);

    //extract textons
    TextonMap textons;
    textons.map.resize(m_lab.size(1),m_lab.size(2));
    textons.numChannels = 0;

    if(config.textonFile == "")
    {
      const int nchannels = config.textonStartChannels;
      computeTextons(*m_lab.slice(Util::LAB_L),fbank,nchannels,textons);
    }
    else
    {
      computeTextons(*m_lab.slice(Util::LAB_L),fbank,config.textonFile,textons);
    }
    Util::Message::debug(Util::String("Used %d textons",textons.numChannels),2);

    m_textonHist(0).resize(m_width,m_height,textons.numChannels);

    Group::computeTextonHistograms(textons,support,m_textonHist(0)); 
  }  

  void
  Region::computeColorHistograms (const SupportMap& support)
  {
    m_aHist.resize(1);
    m_bHist.resize(1);
    m_aHist(0).resize(m_width,m_height,config.cpBinsA);
    m_bHist(0).resize(m_width,m_height,config.cpBinsB);
    Group::computeColorHistograms(*m_lab.slice(Util::LAB_A), config.cpBinsA, config.cpSigma,
                                    config.cpSupport, config.cpZoom, support, m_aHist(0));
    Group::computeColorHistograms(*m_lab.slice(Util::LAB_B), config.cpBinsB, config.cpSigma,
                                    config.cpSupport, config.cpZoom, support, m_bHist(0));
  }

  void
  Region::computeBrightnessHistograms(const SupportMap& support)
  {
      m_lHist.resize(1);
      m_lHist(0).resize(m_width,m_height,config.bpBinsL);
      Group::computeColorHistograms(*m_lab.slice(Util::LAB_L), config.bpBinsL, config.bpSigma,
                                      config.bpSupport, config.bpZoom, support, m_lHist(0));
  }

} //namespace Group