NICE_SemSeg/semseg/operations/Operations.cpp

#include "Operations.h"

using namespace OBJREC;
using namespace std;
using namespace NICE;

Operation::Operation()
{
  init = false;
}

void Operation::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int _featType )
{
  x1 = _x1;
  y1 = _y1;
	z1 = _z1;
  x2 = _x2;
  y2 = _y2;
	z2 = _z2;
  channel1 = _channel1;
  channel2 = _channel2;
  featType = _featType;
  init = true;
}

void Operation::setContext ( bool _context )
{
  context = _context;
}

bool Operation::getContext()
{
  return context;
}

void Operation::setFeatType ( int _featType )
{
  featType = _featType;
}

int Operation::getFeatType()
{
  return featType;
}

void Operation::getXYZ ( const Features &feats, int &xsize, int &ysize, int &zsize )
{
  xsize = feats.feats->width();
  ysize = feats.feats->height();
	zsize = feats.feats->depth();
}


void Operation::store ( std::ostream & os )
{
  os << x1 << " " << x2 << " " << y1 << " " << y2 << " " << z1 << " " << z2 << " " << channel1 << " " << channel2 << " " << featType << std::endl;
  if ( !init )
    os << -1 << std::endl;
  else
  {
    if (featType == 3 || featType == 4)
      os << CONTEXT << std::endl;
    else
      os << RAWFEAT << std::endl;
  }
}

void Operation::restore ( std::istream &is )
{
  is >> x1;
  is >> x2;
  is >> y1;
  is >> y2;
	is >> z1;
  is >> z2;
  is >> channel1;
  is >> channel2;
  is >> featType;

  int tmp;
  is >> tmp;

  if ( tmp >= 0 )
  {
    if ( tmp == RAWFEAT || tmp == CONTEXT )
    {
      init = true;
    }
    else
    {
      throw ( "no valid ValueAccess" );
    }
  }
  else
  {
    init = false;
  }
}

std::string Operation::writeInfos()
{
  std::stringstream ss;
  ss << " x1: " << x1 << " y1: " << y1 << " z1: " << z1 << " x2: " << x2 << " y2: " << y2 << " z2: " << z2 <<  " c1: " << channel1 << " c2: " << channel2;
  return ss.str();
}




//############################## region feature ###############################


double RegionFeat::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  return (*feats.rProbs)[(*feats.feats)(x,y,z,channel1)][channel2];
}




//############################# two gray values ###############################


double Minus::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int xsize, ysize, zsize;
  getXYZ ( feats, xsize, ysize, zsize );

  double v1 = feats.feats->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
  double v2 = feats.feats->get ( BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), channel2 );

  return v1-v2;
}

double MinusAbs::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int xsize, ysize, zsize;
  getXYZ ( feats, xsize, ysize, zsize );

  double v1 = feats.feats->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
  double v2 = feats.feats->get ( BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), channel2 );

  return abs(v1-v2);
}

double Addition::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int xsize, ysize, zsize;
  getXYZ ( feats, xsize, ysize, zsize );

  double v1 = feats.feats->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
  double v2 = feats.feats->get ( BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), channel2 );

  return v1+v2;
}




//############################## one gray value ###############################


double Only1::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int xsize, ysize, zsize;
  getXYZ ( feats, xsize, ysize, zsize );

  return feats.feats->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
}




//############################ relative positions #############################


double RelativeXPosition::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int xsize, ysize, zsize;
  getXYZ ( feats, xsize, ysize, zsize );
  return ( double ) x / ( double ) xsize;
}

double RelativeYPosition::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int xsize, ysize, zsize;
  getXYZ ( feats, xsize, ysize, zsize );
  return ( double ) y / ( double ) ysize;
}

double RelativeZPosition::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int xsize, ysize, zsize;
  getXYZ ( feats, xsize, ysize, zsize );
  return ( double ) z / ( double ) zsize;
}





//########################### integral operations #############################



double GlobalFeats::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int xsize, ysize, zsize;
  getXYZ ( feats, xsize, ysize, zsize );

  return feats.feats->getIntegralValue( 0, 0, 0, xsize - 1, ysize - 1, zsize - 1, channel1 );
}

void IntegralOps::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int _featType )
{
  x1 = std::min ( _x1, _x2 );
  y1 = std::min ( _y1, _y2 );
  z1 = std::min ( _z1, _z2 );
  x2 = std::max ( _x1, _x2 );
  y2 = std::max ( _y1, _y2 );
  z2 = std::max ( _z1, _z2 );
  channel1 = _channel1;
  channel2 = _channel2;
  featType = _featType;
  init = true;
}

double IntegralOps::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  return feats.feats->getIntegralValue(x + x1, y + y1, z + z1, x + x2, y + y2, z + z2, channel1);
}

void IntegralCenteredOps::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int _featType )
{
  x1 = abs ( _x1 );
  y1 = abs ( _y1 );
  z1 = abs ( _z1 );
  x2 = abs ( _x2 );
  y2 = abs ( _y2 );
  z2 = abs ( _z2 );
  channel1 = _channel1;
  channel2 = _channel2;
  featType = _featType;
  init = true;
}

double IntegralCenteredOps::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  return feats.feats->getIntegralValue(x - x1, y - y1, z - z1, x + x1, y + y1, z + z1, channel1);
}

void BiIntegralCenteredOps::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int _featType )
{
  x1 = std::min ( abs ( _x1 ), abs ( _x2 ) );
  y1 = std::min ( abs ( _y1 ), abs ( _y2 ) );
  z1 = std::min ( abs ( _z1 ), abs ( _z2 ) );
  x2 = std::max ( abs ( _x1 ), abs ( _x2 ) );
  y2 = std::max ( abs ( _y1 ), abs ( _y2 ) );
  z2 = std::max ( abs ( _z1 ), abs ( _z2 ) );
  channel1 = _channel1;
  channel2 = _channel2;
  featType = _featType;
  init = true;
}

double BiIntegralCenteredOps::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  return feats.feats->getIntegralValue(x - x1, y - y1, z - z1, x + x1, y + y1, z + z1, channel1 ) - feats.feats->getIntegralValue(x - x2, y - y2, z - z2, x + x2, y + y2, z + z2, channel1);
}






//############################ Haar-like features #############################



double HaarHorizontal::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, lrx, y, lrz, channel1 ) - feats.feats->getIntegralValue(tlx, y, tlz, lrx, lry, lrz, channel1);
}

double HaarVertical::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, x, lry, lrz, channel1) - feats.feats->getIntegralValue(x, tly, tlz, lrx, lry, lrz, channel1);
}

double HaarStacked::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, lrx, lry, z, channel1) - feats.feats->getIntegralValue(tlx, tly, z, lrx, lry, lrz, channel1);
}

double HaarDiagXY::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, x, y, lrz, channel1) + feats.feats->getIntegralValue(x, y, tlz, lrx, lry, lrz, channel1) - feats.feats->getIntegralValue(tlx, y, tlz, x, lry, lrz, channel1) - feats.feats->getIntegralValue(x, tly, tlz, lrx, y, lrz, channel1);
}

double HaarDiagXZ::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, x, lry, z, channel1) + feats.feats->getIntegralValue(x, tly, z, lrx, lry, lrz, channel1) - feats.feats->getIntegralValue(tlx, tly, z, x, lry, lrz, channel1) - feats.feats->getIntegralValue(x, tly, tlz, lrx, lry, z, channel1);
}

double HaarDiagYZ::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, lrx, y, z, channel1) + feats.feats->getIntegralValue(tlx, y, z, lrx, lry, lrz, channel1) - feats.feats->getIntegralValue(tlx, tly, z, lrx, y, lrz, channel1) - feats.feats->getIntegralValue(tlx, y, tlz, lrx, lry, z, channel1);
}

double Haar3Horiz::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);
  int mtly = y - abs(y1);
  int mlry = y + abs(y1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, lrx, mtly, lrz, channel1) - feats.feats->getIntegralValue(tlx, mtly, tlz, lrx, mlry, lrz, channel1) + feats.feats->getIntegralValue(tlx, mlry, tlz, lrx, lry, lrz, channel1);
}

double Haar3Vert::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);
  int mtlx = x - abs(x1);
  int mlrx = x + abs(x1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, mtlx, lry, lrz, channel1) - feats.feats->getIntegralValue(mtlx, tly, tlz, mlrx, lry, lrz, channel1) + feats.feats->getIntegralValue(mlrx, tly, tlz, lrx, lry, lrz, channel1);
}

double Haar3Stack::getVal ( const Features &feats, const int &x, const int &y, const int &z )
{
  int tlx = x - abs(x1);
  int tly = y - abs(y1);
  int tlz = z - abs(z1);
  int lrx = x + abs(x1);
  int lry = y + abs(y1);
  int lrz = z + abs(z1);
  int mtlz = z - abs(z1);
  int mlrz = z + abs(z1);

  return feats.feats->getIntegralValue(tlx, tly, tlz, lrx, lry, mtlz, channel1) - feats.feats->getIntegralValue(tlx, tly, mtlz, lrx, lry, mlrz, channel1) + feats.feats->getIntegralValue(tlx, tly, mlrz, lrx, lry, lrz, channel1);
}




//############################### Ray Features ################################
double RayDiff::getVal( const Features &feats, const int &x, const int &y, const int &z )
{

  double dist1 = feats.feats->get( x, y, z, feats.feats->channels()-16+z1 );
  double dist2 = feats.feats->get( x, y, z, feats.feats->channels()-16+z2 );

  if (dist1 != 0)
    return (dist1-dist2)/dist1;
  else
    return 0.0;
}

double RayDist::getVal( const Features &feats, const int &x, const int &y, const int &z )
{
  return feats.feats->get( x, y, z, feats.feats->channels()-16+z1 );
}

double RayTheta::getVal( const Features &feats, const int &x, const int &y, const int &z )
{
  return 0.0;
}

double RayNorm::getVal( const Features &feats, const int &x, const int &y, const int &z )
{
  return feats.feats->get( x, y, z, feats.feats->channels()-8+z1 );
}