|
@@ -6,11 +6,11 @@ using namespace NICE;
|
|
|
|
|
|
Operation::Operation()
|
|
|
{
|
|
|
- values = NULL;
|
|
|
maxtypes = 1000;
|
|
|
+ init = false;
|
|
|
}
|
|
|
|
|
|
-void Operation::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, ValueAccess *_values )
|
|
|
+void Operation::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int ftype )
|
|
|
{
|
|
|
x1 = _x1;
|
|
|
y1 = _y1;
|
|
@@ -20,7 +20,8 @@ void Operation::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int
|
|
|
z2 = _z2;
|
|
|
channel1 = _channel1;
|
|
|
channel2 = _channel2;
|
|
|
- values = _values;
|
|
|
+ setFeatType(ftype);
|
|
|
+ init = true;
|
|
|
}
|
|
|
|
|
|
void Operation::setContext ( bool _context )
|
|
@@ -54,10 +55,15 @@ void Operation::getXYZ ( const Features &feats, int &xsize, int &ysize, int &zsi
|
|
|
void Operation::store ( std::ostream & os )
|
|
|
{
|
|
|
os << x1 << " " << x2 << " " << y1 << " " << y2 << " " << z1 << " " << z2 << " " << channel1 << " " << channel2 << " " << featType << std::endl;
|
|
|
- if ( values == NULL )
|
|
|
+ if ( !init )
|
|
|
os << -1 << std::endl;
|
|
|
else
|
|
|
- os << values->getType() << std::endl;
|
|
|
+ {
|
|
|
+ if (featType == 4)
|
|
|
+ os << CONTEXT << std::endl;
|
|
|
+ else
|
|
|
+ os << RAWFEAT << std::endl;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
void Operation::restore ( std::istream &is )
|
|
@@ -77,13 +83,9 @@ void Operation::restore ( std::istream &is )
|
|
|
|
|
|
if ( tmp >= 0 )
|
|
|
{
|
|
|
- if ( tmp == RAWFEAT )
|
|
|
- {
|
|
|
- values = new MCImageAccess();
|
|
|
- }
|
|
|
- else if ( tmp == CONTEXT )
|
|
|
+ if ( tmp == RAWFEAT || tmp == CONTEXT )
|
|
|
{
|
|
|
- values = new ClassificationResultAccess();
|
|
|
+ init = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
@@ -92,7 +94,7 @@ void Operation::restore ( std::istream &is )
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
- values = NULL;
|
|
|
+ init = false;
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -103,46 +105,103 @@ std::string Operation::writeInfos()
|
|
|
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 = values->getVal ( feats, BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
|
|
|
- double v2 = values->getVal ( feats, BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), channel2 );
|
|
|
- return v1 -v2;
|
|
|
+
|
|
|
+ double v1,v2;
|
|
|
+ if (featType == 4)
|
|
|
+ {
|
|
|
+ v1 = ( *feats.tree ) [feats.nIndices->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), feats.cTree ) ].dist[channel1];
|
|
|
+ v2 = ( *feats.tree ) [feats.nIndices->get ( BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), feats.cTree ) ].dist[channel2];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ v1 = feats.feats->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
|
|
|
+ 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 = values->getVal ( feats, BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
|
|
|
- double v2 = values->getVal ( feats, BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), channel2 );
|
|
|
- return abs ( v1 -v2 );
|
|
|
+ double v1,v2;
|
|
|
+ if (featType == 4)
|
|
|
+ {
|
|
|
+ v1 = ( *feats.tree ) [feats.nIndices->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), feats.cTree ) ].dist[channel1];
|
|
|
+ v2 = ( *feats.tree ) [feats.nIndices->get ( BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), feats.cTree ) ].dist[channel2];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ v1 = feats.feats->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
|
|
|
+ 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 = values->getVal ( feats, BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
|
|
|
- double v2 = values->getVal ( feats, BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), channel2 );
|
|
|
- return v1 + v2;
|
|
|
+ double v1,v2;
|
|
|
+ if (featType == 4)
|
|
|
+ {
|
|
|
+ v1 = ( *feats.tree ) [feats.nIndices->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), feats.cTree ) ].dist[channel1];
|
|
|
+ v2 = ( *feats.tree ) [feats.nIndices->get ( BOUND ( x + x2, 0, xsize - 1 ), BOUND ( y + y2, 0, ysize - 1 ), BOUND ( z + z2, 0, zsize - 1 ), feats.cTree ) ].dist[channel2];
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ v1 = feats.feats->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
|
|
|
+ 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 );
|
|
|
- double v1 = values->getVal ( feats, BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
|
|
|
+ double v1;
|
|
|
+ if (featType == 4)
|
|
|
+ v1 = ( *feats.tree ) [feats.nIndices->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), feats.cTree ) ].dist[channel1];
|
|
|
+ else
|
|
|
+ v1 = feats.feats->get ( BOUND ( x + x1, 0, xsize - 1 ), BOUND ( y + y1, 0, ysize - 1 ), BOUND ( z + z1, 0, zsize - 1 ), channel1 );
|
|
|
+
|
|
|
return v1;
|
|
|
}
|
|
|
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+//############################ relative positions #############################
|
|
|
+
|
|
|
+
|
|
|
double RelativeXPosition::getVal ( const Features &feats, const int &x, const int &y, const int &z )
|
|
|
{
|
|
|
int xsize, ysize, zsize;
|
|
@@ -164,10 +223,13 @@ double RelativeZPosition::getVal ( const Features &feats, const int &x, const in
|
|
|
return ( double ) z / ( double ) zsize;
|
|
|
}
|
|
|
|
|
|
-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);
|
|
|
-}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+//########################### integral operations #############################
|
|
|
+
|
|
|
+
|
|
|
|
|
|
double GlobalFeats::getVal ( const Features &feats, const int &x, const int &y, const int &z )
|
|
|
{
|
|
@@ -176,165 +238,179 @@ double GlobalFeats::getVal ( const Features &feats, const int &x, const int &y,
|
|
|
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 ftype )
|
|
|
+{
|
|
|
+ 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;
|
|
|
+ setFeatType(ftype);
|
|
|
+}
|
|
|
+
|
|
|
+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 ftype )
|
|
|
+{
|
|
|
+ x1 = abs ( _x1 );
|
|
|
+ y1 = abs ( _y1 );
|
|
|
+ z1 = abs ( _z1 );
|
|
|
+ x2 = abs ( _x2 );
|
|
|
+ y2 = abs ( _y2 );
|
|
|
+ z2 = abs ( _z2 );
|
|
|
+ channel1 = _channel1;
|
|
|
+ channel2 = _channel2;
|
|
|
+ setFeatType(ftype);
|
|
|
+}
|
|
|
+
|
|
|
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 ftype )
|
|
|
+{
|
|
|
+ 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;
|
|
|
+ setFeatType(ftype);
|
|
|
+}
|
|
|
+
|
|
|
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 - x1;
|
|
|
- int tly = y - y1;
|
|
|
- int tlz = z - z1;
|
|
|
- int lrx = x + x1;
|
|
|
- int lry = y + y1;
|
|
|
- int lrz = z + z1;
|
|
|
+ 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 - x1;
|
|
|
- int tly = y - y1;
|
|
|
- int tlz = z - z1;
|
|
|
- int lrx = x + x1;
|
|
|
- int lry = y + y1;
|
|
|
- int lrz = z + z1;
|
|
|
+ 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 - x1;
|
|
|
- int tly = y - y1;
|
|
|
- int tlz = z - z1;
|
|
|
- int lrx = x + x1;
|
|
|
- int lry = y + y1;
|
|
|
- int lrz = z + z1;
|
|
|
+ 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 - x1;
|
|
|
- int tly = y - y1;
|
|
|
- int tlz = z - z1;
|
|
|
- int lrx = x + x1;
|
|
|
- int lry = y + y1;
|
|
|
- int lrz = z + z1;
|
|
|
+ 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 - x1;
|
|
|
- int tly = y - y1;
|
|
|
- int tlz = z - z1;
|
|
|
- int lrx = x + x1;
|
|
|
- int lry = y + y1;
|
|
|
- int lrz = z + z1;
|
|
|
+ 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 - x1;
|
|
|
- int tly = y - y1;
|
|
|
- int tlz = z - z1;
|
|
|
- int lrx = x + x1;
|
|
|
- int lry = y + y1;
|
|
|
- int lrz = z + z1;
|
|
|
+ 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 - x2;
|
|
|
- int tly = y - y2;
|
|
|
- int tlz = z - z2;
|
|
|
- int mtly = y - y1;
|
|
|
- int mlry = y + y1;
|
|
|
- int lrx = x + x2;
|
|
|
- int lry = y + y2;
|
|
|
- int lrz = z + z2;
|
|
|
+ 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 - x2;
|
|
|
- int tly = y - y2;
|
|
|
- int tlz = z - z2;
|
|
|
- int mtlx = x - x1;
|
|
|
- int mlrx = x + x1;
|
|
|
- int lrx = x + x2;
|
|
|
- int lry = y + y2;
|
|
|
- int lrz = z + z2;
|
|
|
+ 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 - x2;
|
|
|
- int tly = y - y2;
|
|
|
- int tlz = z - z2;
|
|
|
- int mtlz = z - z1;
|
|
|
- int mlrz = z + z1;
|
|
|
- int lrx = x + x2;
|
|
|
- int lry = y + y2;
|
|
|
- int lrz = z + z2;
|
|
|
+ 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);
|
|
|
}
|
|
|
-
|
|
|
-void IntegralOps::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, ValueAccess *_values )
|
|
|
-{
|
|
|
- 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;
|
|
|
- values = _values;
|
|
|
-}
|
|
|
-
|
|
|
-void IntegralCenteredOps::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, ValueAccess *_values )
|
|
|
-{
|
|
|
- x1 = abs ( _x1 );
|
|
|
- y1 = abs ( _y1 );
|
|
|
- z1 = abs ( _z1 );
|
|
|
- x2 = abs ( _x2 );
|
|
|
- y2 = abs ( _y2 );
|
|
|
- z2 = abs ( _z2 );
|
|
|
- channel1 = _channel1;
|
|
|
- channel2 = _channel2;
|
|
|
- values = _values;
|
|
|
-}
|
|
|
-
|
|
|
-void BiIntegralCenteredOps::set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, ValueAccess *_values )
|
|
|
-{
|
|
|
- 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;
|
|
|
- values = _values;
|
|
|
-}
|