added COVAR_ and SORT_ enums to core.hpp; fixed many, many VS2005, VS2010 and MinGW (GCC 4.5.2) warnings
This commit is contained in:
Vadim Pisarevsky
parent
6bb1c07fd4
commit
ff5e97c8e4
@ -52,11 +52,12 @@ using namespace std;
|
||||
|
||||
void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> points, const Size &patternSize, vector<Point2f> &patternPoints)
|
||||
{
|
||||
Mat dists(points.size(), points.size(), CV_32FC1, Scalar(0));
|
||||
int i, j, n = (int)points.size();
|
||||
Mat dists(n, n, CV_32FC1, Scalar(0));
|
||||
Mat distsMask(dists.size(), CV_8UC1, Scalar(0));
|
||||
for(size_t i=0; i<points.size(); i++)
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
for(size_t j=i+1; j<points.size(); j++)
|
||||
for(j = i+1; j < n; j++)
|
||||
{
|
||||
dists.at<float>(i, j) = (float)norm(points[i] - points[j]);
|
||||
distsMask.at<uchar>(i, j) = 255;
|
||||
@ -184,10 +185,11 @@ void CirclesGridClusterFinder::findOutsideCorners(const std::vector<cv::Point2f>
|
||||
double min1 = std::numeric_limits<double>::max();
|
||||
double min2 = std::numeric_limits<double>::max();
|
||||
Point minLoc1, minLoc2;
|
||||
int i, j, n = (int)corners.size();
|
||||
|
||||
for(size_t i=0; i<corners.size(); i++)
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
for(size_t j=i+1; j<corners.size(); j++)
|
||||
for(j = i+1; j < n; j++)
|
||||
{
|
||||
double dist = norm(corners[i] - corners[j]);
|
||||
Point loc(j, i);
|
||||
@ -209,7 +211,7 @@ void CirclesGridClusterFinder::findOutsideCorners(const std::vector<cv::Point2f>
|
||||
}
|
||||
}
|
||||
std::set<int> outsideCornersIndices;
|
||||
for(size_t i=0; i<corners.size(); i++)
|
||||
for(i = 0; i < n; i++)
|
||||
{
|
||||
outsideCornersIndices.insert(i);
|
||||
}
|
||||
@ -417,16 +419,16 @@ void Graph::floydWarshall(cv::Mat &distanceMatrix, int infinity) const
|
||||
{
|
||||
const int edgeWeight = 1;
|
||||
|
||||
const size_t n = getVerticesCount();
|
||||
const int n = (int)getVerticesCount();
|
||||
distanceMatrix.create(n, n, CV_32SC1);
|
||||
distanceMatrix.setTo(infinity);
|
||||
for (Vertices::const_iterator it1 = vertices.begin(); it1 != vertices.end(); it1++)
|
||||
{
|
||||
distanceMatrix.at<int> (it1->first, it1->first) = 0;
|
||||
distanceMatrix.at<int> ((int)it1->first, (int)it1->first) = 0;
|
||||
for (Neighbors::const_iterator it2 = it1->second.neighbors.begin(); it2 != it1->second.neighbors.end(); it2++)
|
||||
{
|
||||
assert( it1->first != *it2 );
|
||||
distanceMatrix.at<int> (it1->first, *it2) = edgeWeight;
|
||||
distanceMatrix.at<int> ((int)it1->first, (int)*it2) = edgeWeight;
|
||||
}
|
||||
}
|
||||
|
||||
@ -436,17 +438,17 @@ void Graph::floydWarshall(cv::Mat &distanceMatrix, int infinity) const
|
||||
{
|
||||
for (Vertices::const_iterator it3 = vertices.begin(); it3 != vertices.end(); it3++)
|
||||
{
|
||||
int val1 = distanceMatrix.at<int> (it2->first, it3->first);
|
||||
int i1 = (int)it1->first, i2 = (int)it2->first, i3 = (int)it3->first;
|
||||
int val1 = distanceMatrix.at<int> (i2, i3);
|
||||
int val2;
|
||||
if (distanceMatrix.at<int> (it2->first, it1->first) == infinity || distanceMatrix.at<int> (it1->first,
|
||||
it3->first)
|
||||
== infinity)
|
||||
if (distanceMatrix.at<int> (i2, i1) == infinity ||
|
||||
distanceMatrix.at<int> (i1, i3) == infinity)
|
||||
val2 = val1;
|
||||
else
|
||||
{
|
||||
val2 = distanceMatrix.at<int> (it2->first, it1->first) + distanceMatrix.at<int> (it1->first, it3->first);
|
||||
val2 = distanceMatrix.at<int> (i2, i1) + distanceMatrix.at<int> (i1, i3);
|
||||
}
|
||||
distanceMatrix.at<int> (it2->first, it3->first) = (val1 == infinity) ? val2 : std::min(val1, val2);
|
||||
distanceMatrix.at<int> (i2, i3) = (val1 == infinity) ? val2 : std::min(val1, val2);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1045,7 +1047,7 @@ void CirclesGridFinder::findBasis(const vector<Point2f> &samples, vector<Point2f
|
||||
CV_Error(0, "degenerate basis" );
|
||||
|
||||
vector<vector<Point2f> > clusters(2), hulls(2);
|
||||
for (size_t k = 0; k < samples.size(); k++)
|
||||
for (int k = 0; k < (int)samples.size(); k++)
|
||||
{
|
||||
int label = bestLabels.at<int> (k, 0);
|
||||
int idx = -1;
|
||||
@ -1156,13 +1158,13 @@ void computePredecessorMatrix(const Mat &dm, int verticesCount, Mat &predecessor
|
||||
|
||||
void computeShortestPath(Mat &predecessorMatrix, size_t v1, size_t v2, vector<size_t> &path)
|
||||
{
|
||||
if (predecessorMatrix.at<int> (v1, v2) < 0)
|
||||
if (predecessorMatrix.at<int> ((int)v1, (int)v2) < 0)
|
||||
{
|
||||
path.push_back(v1);
|
||||
return;
|
||||
}
|
||||
|
||||
computeShortestPath(predecessorMatrix, v1, predecessorMatrix.at<int> (v1, v2), path);
|
||||
computeShortestPath(predecessorMatrix, v1, predecessorMatrix.at<int> ((int)v1, (int)v2), path);
|
||||
path.push_back(v2);
|
||||
}
|
||||
|
||||
@ -1179,7 +1181,7 @@ size_t CirclesGridFinder::findLongestPath(vector<Graph> &basisGraphs, Path &best
|
||||
Mat distanceMatrix;
|
||||
g.floydWarshall(distanceMatrix, infinity);
|
||||
Mat predecessorMatrix;
|
||||
computePredecessorMatrix(distanceMatrix, g.getVerticesCount(), predecessorMatrix);
|
||||
computePredecessorMatrix(distanceMatrix, (int)g.getVerticesCount(), predecessorMatrix);
|
||||
|
||||
double maxVal;
|
||||
Point maxLoc;
|
||||
@ -1203,9 +1205,9 @@ size_t CirclesGridFinder::findLongestPath(vector<Graph> &basisGraphs, Path &best
|
||||
longestPaths.push_back(path);
|
||||
|
||||
int conf = 0;
|
||||
for (size_t v2 = 0; v2 < path.vertices.size(); v2++)
|
||||
for (int v2 = 0; v2 < (int)path.vertices.size(); v2++)
|
||||
{
|
||||
conf += basisGraphs[1 - (int)graphIdx].getDegree(v2);
|
||||
conf += (int)basisGraphs[1 - (int)graphIdx].getDegree(v2);
|
||||
}
|
||||
confidences.push_back(conf);
|
||||
}
|
||||
@ -1215,7 +1217,7 @@ size_t CirclesGridFinder::findLongestPath(vector<Graph> &basisGraphs, Path &best
|
||||
|
||||
int maxConf = -1;
|
||||
int bestPathIdx = -1;
|
||||
for (size_t i = 0; i < confidences.size(); i++)
|
||||
for (int i = 0; i < (int)confidences.size(); i++)
|
||||
{
|
||||
if (confidences[i] > maxConf)
|
||||
{
|
||||
@ -1241,7 +1243,7 @@ void CirclesGridFinder::drawBasis(const vector<Point2f> &basis, Point2f origin,
|
||||
for (size_t i = 0; i < basis.size(); i++)
|
||||
{
|
||||
Point2f pt(basis[i]);
|
||||
line(drawImg, origin, origin + pt, Scalar(0, i * 255, 0), 2);
|
||||
line(drawImg, origin, origin + pt, Scalar(0, (double)(i * 255), 0), 2);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1318,7 +1320,7 @@ Size CirclesGridFinder::getDetectedGridSize() const
|
||||
if (holes.size() == 0)
|
||||
return Size(0, 0);
|
||||
|
||||
return Size(holes[0].size(), holes.size());
|
||||
return Size((int)holes[0].size(), (int)holes.size());
|
||||
}
|
||||
|
||||
void CirclesGridFinder::getHoles(vector<Point2f> &outHoles) const
|
||||
@ -1411,8 +1413,8 @@ void CirclesGridFinder::getCornerSegments(const vector<vector<size_t> > &points,
|
||||
cornerIndices.clear();
|
||||
firstSteps.clear();
|
||||
secondSteps.clear();
|
||||
size_t h = points.size();
|
||||
size_t w = points[0].size();
|
||||
int h = (int)points.size();
|
||||
int w = (int)points[0].size();
|
||||
CV_Assert(h >= 2 && w >= 2)
|
||||
;
|
||||
|
||||
|
||||
@ -132,7 +132,7 @@ namespace cv
|
||||
const Mat& rvecInit, const Mat& tvecInit, Mutex& resultsMutex)
|
||||
{
|
||||
Mat modelObjectPoints(1, MIN_POINTS_COUNT, CV_32FC3), modelImagePoints(1, MIN_POINTS_COUNT, CV_32FC2);
|
||||
for (size_t i = 0, colIndex = 0; i < pointsMask.size(); i++)
|
||||
for (int i = 0, colIndex = 0; i < (int)pointsMask.size(); i++)
|
||||
{
|
||||
if (pointsMask[i])
|
||||
{
|
||||
@ -239,8 +239,8 @@ namespace cv
|
||||
|
||||
void generateVar(vector<char>& mask) const
|
||||
{
|
||||
size_t size = mask.size();
|
||||
for (size_t i = 0; i < size; i++)
|
||||
int size = (int)mask.size();
|
||||
for (int i = 0; i < size; i++)
|
||||
{
|
||||
int i1 = generator.uniform(0, size);
|
||||
int i2 = generator.uniform(0, size);
|
||||
@ -302,12 +302,11 @@ void cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints,
|
||||
|
||||
if (localInliers.size() >= (size_t)pnpransac::MIN_POINTS_COUNT)
|
||||
{
|
||||
size_t pointsCount = localInliers.size();
|
||||
int i, pointsCount = (int)localInliers.size();
|
||||
Mat inlierObjectPoints(1, pointsCount, CV_32FC3), inlierImagePoints(1, pointsCount, CV_32FC2);
|
||||
int index;
|
||||
for (size_t i = 0; i < localInliers.size(); i++)
|
||||
for (i = 0; i < pointsCount; i++)
|
||||
{
|
||||
index = localInliers[i];
|
||||
int index = localInliers[i];
|
||||
Mat colInlierImagePoints = inlierImagePoints(Rect(i, 0, 1, 1));
|
||||
imagePoints.col(index).copyTo(colInlierImagePoints);
|
||||
Mat colInlierObjectPoints = inlierObjectPoints(Rect(i, 0, 1, 1));
|
||||
|
||||
@ -372,7 +372,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
|
||||
{
|
||||
count = src.rows;
|
||||
sdims = src.channels()*src.cols;
|
||||
sstep1 = src.step/sizeof(double);
|
||||
sstep1 = (int)(src.step/sizeof(double));
|
||||
sstep2 = 1;
|
||||
}
|
||||
else
|
||||
@ -387,7 +387,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
|
||||
else
|
||||
{
|
||||
sstep1 = 1;
|
||||
sstep2 = src.step/sizeof(double);
|
||||
sstep2 = (int)(src.step/sizeof(double));
|
||||
}
|
||||
}
|
||||
|
||||
@ -395,7 +395,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
|
||||
{
|
||||
CV_Assert( count == dst.rows );
|
||||
ddims = dst.channels()*dst.cols;
|
||||
dstep1 = dst.step/sizeof(double);
|
||||
dstep1 = (int)(dst.step/sizeof(double));
|
||||
dstep2 = 1;
|
||||
}
|
||||
else
|
||||
@ -410,7 +410,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
|
||||
else
|
||||
{
|
||||
dstep1 = 1;
|
||||
dstep2 = dst.step/sizeof(double);
|
||||
dstep2 = (int)(dst.step/sizeof(double));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -995,8 +995,8 @@ void LevMarqSparse::bundleAdjust( vector<Point3d>& points, //positions of points
|
||||
const TermCriteria& criteria,
|
||||
BundleAdjustCallback cb, void* user_data) {
|
||||
//,enum{MOTION_AND_STRUCTURE,MOTION,STRUCTURE})
|
||||
int num_points = points.size();
|
||||
int num_cameras = cameraMatrix.size();
|
||||
int num_points = (int)points.size();
|
||||
int num_cameras = (int)cameraMatrix.size();
|
||||
|
||||
CV_Assert( imagePoints.size() == (size_t)num_cameras &&
|
||||
visibility.size() == (size_t)num_cameras &&
|
||||
|
||||
@ -736,7 +736,7 @@ float ChamferMatcher::Matching::getAngle(coordinate_t a, coordinate_t b, int& dx
|
||||
void ChamferMatcher::Matching::findContourOrientations(const template_coords_t& coords, template_orientations_t& orientations)
|
||||
{
|
||||
const int M = 5;
|
||||
int coords_size = coords.size();
|
||||
int coords_size = (int)coords.size();
|
||||
|
||||
std::vector<float> angles(2*M);
|
||||
orientations.insert(orientations.begin(), coords_size, float(-3*CV_PI)); // mark as invalid in the beginning
|
||||
@ -808,11 +808,12 @@ ChamferMatcher::Template::Template(Mat& edge_image, float scale_) : addr_width(-
|
||||
|
||||
size.width = max.x - min.x;
|
||||
size.height = max.y - min.y;
|
||||
int coords_size = (int)coords.size();
|
||||
|
||||
center.x /= (coords.size()==0?1:coords.size());
|
||||
center.y /= (coords.size()==0?1:coords.size());
|
||||
center.x /= MAX(coords_size, 1);
|
||||
center.y /= MAX(coords_size, 1);
|
||||
|
||||
for (size_t i=0;i<coords.size();++i) {
|
||||
for (int i=0;i<coords_size;++i) {
|
||||
coords[i].first -= center.x;
|
||||
coords[i].second -= center.y;
|
||||
}
|
||||
|
||||
@ -442,11 +442,11 @@ void cv::Mesh3D::clearOctree(){ octree = Octree(); }
|
||||
|
||||
float cv::Mesh3D::estimateResolution(float tryRatio)
|
||||
{
|
||||
const size_t neighbors = 3;
|
||||
const size_t minReasonable = 10;
|
||||
const int neighbors = 3;
|
||||
const int minReasonable = 10;
|
||||
|
||||
size_t tryNum = static_cast<size_t>(tryRatio * vtx.size());
|
||||
tryNum = min(max(tryNum, minReasonable), vtx.size());
|
||||
int tryNum = static_cast<int>(tryRatio * vtx.size());
|
||||
tryNum = min(max(tryNum, minReasonable), (int)vtx.size());
|
||||
|
||||
CvMat desc = cvMat((int)vtx.size(), 3, CV_32F, &vtx[0]);
|
||||
CvFeatureTree* tr = cvCreateKDTree(&desc);
|
||||
@ -456,7 +456,7 @@ float cv::Mesh3D::estimateResolution(float tryRatio)
|
||||
vector<Point3f> query;
|
||||
|
||||
RNG& rng = theRNG();
|
||||
for(size_t i = 0; i < tryNum; ++i)
|
||||
for(int i = 0; i < tryNum; ++i)
|
||||
query.push_back(vtx[rng.next() % vtx.size()]);
|
||||
|
||||
CvMat cvinds = cvMat( (int)tryNum, neighbors, CV_32S, &inds[0] );
|
||||
@ -466,7 +466,7 @@ float cv::Mesh3D::estimateResolution(float tryRatio)
|
||||
cvReleaseFeatureTree(tr);
|
||||
|
||||
const int invalid_dist = -2;
|
||||
for(size_t i = 0; i < tryNum; ++i)
|
||||
for(int i = 0; i < tryNum; ++i)
|
||||
if (inds[i] == -1)
|
||||
dist[i] = invalid_dist;
|
||||
|
||||
@ -713,8 +713,8 @@ void cv::SpinImageModel::defaultParams()
|
||||
|
||||
Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount, size_t yCount) const
|
||||
{
|
||||
size_t spinNum = getSpinCount();
|
||||
size_t num = min(spinNum, xCount * yCount);
|
||||
int spinNum = (int)getSpinCount();
|
||||
int num = min(spinNum, (int)(xCount * yCount));
|
||||
|
||||
if (num == 0)
|
||||
return Mat();
|
||||
@ -722,11 +722,11 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
|
||||
RNG& rng = theRNG();
|
||||
|
||||
vector<Mat> spins;
|
||||
for(size_t i = 0; i < num; ++i)
|
||||
for(int i = 0; i < num; ++i)
|
||||
spins.push_back(getSpinImage( rng.next() % spinNum ).reshape(1, imageWidth));
|
||||
|
||||
if (separateScale)
|
||||
for(size_t i = 0; i < num; ++i)
|
||||
for(int i = 0; i < num; ++i)
|
||||
{
|
||||
double max;
|
||||
Mat spin8u;
|
||||
@ -737,14 +737,14 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
|
||||
else
|
||||
{
|
||||
double totalMax = 0;
|
||||
for(size_t i = 0; i < num; ++i)
|
||||
for(int i = 0; i < num; ++i)
|
||||
{
|
||||
double m;
|
||||
minMaxLoc(spins[i], 0, &m);
|
||||
totalMax = max(m, totalMax);
|
||||
}
|
||||
|
||||
for(size_t i = 0; i < num; ++i)
|
||||
for(int i = 0; i < num; ++i)
|
||||
{
|
||||
Mat spin8u;
|
||||
spins[i].convertTo(spin8u, CV_8U, -255.0/totalMax, 255.0);
|
||||
@ -757,16 +757,16 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
|
||||
Mat result((int)(yCount * sz + (yCount - 1)), (int)(xCount * sz + (xCount - 1)), CV_8UC3);
|
||||
result = colors[(static_cast<int64>(cvGetTickCount()/cvGetTickFrequency())/1000) % colors_mum];
|
||||
|
||||
size_t pos = 0;
|
||||
for(size_t y = 0; y < yCount; ++y)
|
||||
for(size_t x = 0; x < xCount; ++x)
|
||||
int pos = 0;
|
||||
for(int y = 0; y < (int)yCount; ++y)
|
||||
for(int x = 0; x < (int)xCount; ++x)
|
||||
if (pos < num)
|
||||
{
|
||||
int starty = (int)((y + 0) * sz + y);
|
||||
int endy = (int)((y + 1) * sz + y);
|
||||
int starty = (y + 0) * sz + y;
|
||||
int endy = (y + 1) * sz + y;
|
||||
|
||||
int startx = (int)((x + 0) * sz + x);
|
||||
int endx = (int)((x + 1) * sz + x);
|
||||
int startx = (x + 0) * sz + x;
|
||||
int endx = (x + 1) * sz + x;
|
||||
|
||||
Mat color;
|
||||
cvtColor(spins[pos++], color, CV_GRAY2BGR);
|
||||
|
||||
@ -2150,6 +2150,15 @@ CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU)
|
||||
//! solves linear system or a least-square problem
|
||||
CV_EXPORTS_W bool solve(InputArray src1, InputArray src2,
|
||||
OutputArray dst, int flags=DECOMP_LU);
|
||||
|
||||
enum
|
||||
{
|
||||
SORT_EVERY_ROW=0,
|
||||
SORT_EVERY_COLUMN=1,
|
||||
SORT_ASCENDING=0,
|
||||
SORT_DESCENDING=16
|
||||
};
|
||||
|
||||
//! sorts independently each matrix row or each matrix column
|
||||
CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags);
|
||||
//! sorts independently each matrix row or each matrix column
|
||||
@ -2167,7 +2176,17 @@ CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues,
|
||||
int lowindex=-1, int highindex=-1);
|
||||
CV_EXPORTS_W bool eigen(InputArray src, bool computeEigenvectors,
|
||||
OutputArray eigenvalues, OutputArray eigenvectors);
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
COVAR_SCRAMBLED=0,
|
||||
COVAR_NORMAL=1,
|
||||
COVAR_USE_AVG=2,
|
||||
COVAR_SCALE=4,
|
||||
COVAR_ROWS=8,
|
||||
COVAR_COLS=16
|
||||
};
|
||||
|
||||
//! computes covariation matrix of a set of samples
|
||||
CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean,
|
||||
int flags, int ctype=CV_64F);
|
||||
|
||||
@ -2780,7 +2780,8 @@ public:
|
||||
size_t remaining = it->remaining, cn = DataType<_Tp>::channels;
|
||||
int _fmt = DataType<_Tp>::fmt;
|
||||
char fmt[] = { (char)((_fmt>>8)+'1'), (char)_fmt, '\0' };
|
||||
count = std::min(count, remaining/cn);
|
||||
size_t remaining1 = remaining/cn;
|
||||
count = count < remaining1 ? count : remaining1;
|
||||
vec.resize(count);
|
||||
it->readRaw( string(fmt), (uchar*)&vec[0], count*sizeof(_Tp) );
|
||||
}
|
||||
|
||||
@ -68,7 +68,9 @@ struct NOP {};
|
||||
template<typename T, class Op, class Op8>
|
||||
void vBinOp8(const T* src1, size_t step1, const T* src2, size_t step2, T* dst, size_t step, Size sz)
|
||||
{
|
||||
#if CV_SSE2
|
||||
Op8 op8;
|
||||
#endif
|
||||
Op op;
|
||||
|
||||
for( ; sz.height--; src1 += step1/sizeof(src1[0]),
|
||||
@ -117,7 +119,9 @@ template<typename T, class Op, class Op16>
|
||||
void vBinOp16(const T* src1, size_t step1, const T* src2, size_t step2,
|
||||
T* dst, size_t step, Size sz)
|
||||
{
|
||||
#if CV_SSE2
|
||||
Op16 op16;
|
||||
#endif
|
||||
Op op;
|
||||
|
||||
for( ; sz.height--; src1 += step1/sizeof(src1[0]),
|
||||
@ -168,7 +172,9 @@ template<class Op, class Op32>
|
||||
void vBinOp32s(const int* src1, size_t step1, const int* src2, size_t step2,
|
||||
int* dst, size_t step, Size sz)
|
||||
{
|
||||
#if CV_SSE2
|
||||
Op32 op32;
|
||||
#endif
|
||||
Op op;
|
||||
|
||||
for( ; sz.height--; src1 += step1/sizeof(src1[0]),
|
||||
@ -223,7 +229,9 @@ template<class Op, class Op32>
|
||||
void vBinOp32f(const float* src1, size_t step1, const float* src2, size_t step2,
|
||||
float* dst, size_t step, Size sz)
|
||||
{
|
||||
#if CV_SSE2
|
||||
Op32 op32;
|
||||
#endif
|
||||
Op op;
|
||||
|
||||
for( ; sz.height--; src1 += step1/sizeof(src1[0]),
|
||||
@ -276,7 +284,9 @@ template<class Op, class Op64>
|
||||
void vBinOp64f(const double* src1, size_t step1, const double* src2, size_t step2,
|
||||
double* dst, size_t step, Size sz)
|
||||
{
|
||||
#if CV_SSE2
|
||||
Op64 op64;
|
||||
#endif
|
||||
Op op;
|
||||
|
||||
for( ; sz.height--; src1 += step1/sizeof(src1[0]),
|
||||
@ -1064,7 +1074,7 @@ void binary_op(InputArray _src1, InputArray _src2, OutputArray _dst,
|
||||
{
|
||||
for( size_t j = 0; j < total; j += blocksize )
|
||||
{
|
||||
int bsz = (int)std::min(total - j, blocksize);
|
||||
int bsz = (int)MIN(total - j, blocksize);
|
||||
|
||||
func( ptrs[0], 0, ptrs[1], 0, haveMask ? maskbuf : ptrs[2], 0, Size(bsz*c, 1), 0 );
|
||||
if( haveMask )
|
||||
@ -1096,7 +1106,7 @@ void binary_op(InputArray _src1, InputArray _src2, OutputArray _dst,
|
||||
{
|
||||
for( size_t j = 0; j < total; j += blocksize )
|
||||
{
|
||||
int bsz = (int)std::min(total - j, blocksize);
|
||||
int bsz = (int)MIN(total - j, blocksize);
|
||||
|
||||
func( ptrs[0], 0, scbuf, 0, haveMask ? maskbuf : ptrs[1], 0, Size(bsz*c, 1), 0 );
|
||||
if( haveMask )
|
||||
@ -1322,7 +1332,7 @@ void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
|
||||
{
|
||||
for( size_t j = 0; j < total; j += blocksize )
|
||||
{
|
||||
int bsz = (int)std::min(total - j, blocksize);
|
||||
int bsz = (int)MIN(total - j, blocksize);
|
||||
Size bszn(bsz*cn, 1);
|
||||
const uchar *sptr1 = ptrs[0], *sptr2 = ptrs[1];
|
||||
uchar* dptr = ptrs[2];
|
||||
@ -1387,7 +1397,7 @@ void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
|
||||
{
|
||||
for( size_t j = 0; j < total; j += blocksize )
|
||||
{
|
||||
int bsz = (int)std::min(total - j, blocksize);
|
||||
int bsz = (int)MIN(total - j, blocksize);
|
||||
Size bszn(bsz*cn, 1);
|
||||
const uchar *sptr1 = ptrs[0];
|
||||
const uchar* sptr2 = buf2;
|
||||
@ -2181,7 +2191,7 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
|
||||
{
|
||||
for( size_t j = 0; j < total; j += blocksize )
|
||||
{
|
||||
int bsz = (int)std::min(total - j, blocksize);
|
||||
int bsz = (int)MIN(total - j, blocksize);
|
||||
func( ptrs[0], 0, buf, 0, ptrs[1], 0, Size(bsz, 1), &op);
|
||||
ptrs[0] += bsz*esz;
|
||||
ptrs[1] += bsz;
|
||||
@ -2387,7 +2397,7 @@ void cv::inRange(InputArray _src, InputArray _lowerb,
|
||||
{
|
||||
for( size_t j = 0; j < total; j += blocksize )
|
||||
{
|
||||
int bsz = (int)std::min(total - j, blocksize);
|
||||
int bsz = (int)MIN(total - j, blocksize);
|
||||
size_t delta = bsz*esz;
|
||||
uchar *lptr = lbuf, *uptr = ubuf;
|
||||
if( !lbScalar )
|
||||
|
||||
@ -181,7 +181,7 @@ std::string CommandLineParser::getString(const std::string& keys) const
|
||||
}
|
||||
|
||||
if (is_cur_found)
|
||||
found_index=j;
|
||||
found_index=(int)j;
|
||||
}
|
||||
|
||||
if (found_index<0)
|
||||
|
||||
@ -220,7 +220,7 @@ void cv::split(const Mat& src, Mat* mv)
|
||||
SplitFunc func = splitTab[depth];
|
||||
CV_Assert( func != 0 );
|
||||
|
||||
int esz = src.elemSize(), esz1 = src.elemSize1();
|
||||
int esz = (int)src.elemSize(), esz1 = (int)src.elemSize1();
|
||||
int blocksize0 = (BLOCK_SIZE + esz-1)/esz;
|
||||
AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
|
||||
const Mat** arrays = (const Mat**)(uchar*)_buf;
|
||||
@ -305,7 +305,7 @@ void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
|
||||
}
|
||||
|
||||
size_t esz = dst.elemSize(), esz1 = dst.elemSize1();
|
||||
int blocksize0 = (BLOCK_SIZE + esz-1)/esz;
|
||||
int blocksize0 = (int)((BLOCK_SIZE + esz-1)/esz);
|
||||
AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
|
||||
const Mat** arrays = (const Mat**)(uchar*)_buf;
|
||||
uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
|
||||
@ -451,12 +451,12 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
|
||||
if( i0 < src[j].channels() )
|
||||
break;
|
||||
CV_Assert(j < nsrcs && src[j].depth() == depth);
|
||||
tab[i*4] = j; tab[i*4+1] = i0*esz1;
|
||||
tab[i*4] = (int)j; tab[i*4+1] = (int)(i0*esz1);
|
||||
sdelta[i] = src[j].channels();
|
||||
}
|
||||
else
|
||||
{
|
||||
tab[i*4] = nsrcs + ndsts; tab[i*4+1] = 0;
|
||||
tab[i*4] = (int)(nsrcs + ndsts); tab[i*4+1] = 0;
|
||||
sdelta[i] = 0;
|
||||
}
|
||||
|
||||
@ -464,11 +464,11 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
|
||||
if( i1 < dst[j].channels() )
|
||||
break;
|
||||
CV_Assert(i1 >= 0 && j < ndsts && dst[j].depth() == depth);
|
||||
tab[i*4+2] = j + nsrcs; tab[i*4+3] = i1*esz1;
|
||||
tab[i*4+2] = (int)(j + nsrcs); tab[i*4+3] = (int)(i1*esz1);
|
||||
ddelta[i] = dst[j].channels();
|
||||
}
|
||||
|
||||
NAryMatIterator it(arrays, ptrs, nsrcs + ndsts);
|
||||
NAryMatIterator it(arrays, ptrs, (int)(nsrcs + ndsts));
|
||||
int total = (int)it.size, blocksize = std::min(total, (int)((BLOCK_SIZE + esz1-1)/esz1));
|
||||
MixChannelsFunc func = mixchTab[depth];
|
||||
|
||||
@ -508,7 +508,7 @@ void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
|
||||
{
|
||||
if(fromTo.empty())
|
||||
return;
|
||||
size_t i, nsrc = src.total(), ndst = dst.total();
|
||||
int i, nsrc = (int)src.total(), ndst = (int)dst.total();
|
||||
CV_Assert(fromTo.size()%2 == 0 && nsrc > 0 && ndst > 0);
|
||||
cv::AutoBuffer<Mat> _buf(nsrc + ndst);
|
||||
Mat* buf = _buf;
|
||||
@ -516,7 +516,7 @@ void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
|
||||
buf[i] = src.getMat(i);
|
||||
for( i = 0; i < ndst; i++ )
|
||||
buf[nsrc + i] = dst.getMat(i);
|
||||
mixChannels(&buf[0], (int)nsrc, &buf[nsrc], (int)ndst, &fromTo[0], (int)(fromTo.size()/2));
|
||||
mixChannels(&buf[0], nsrc, &buf[nsrc], ndst, &fromTo[0], fromTo.size()/2);
|
||||
}
|
||||
|
||||
void cv::extractChannel(InputArray _src, OutputArray _dst, int coi)
|
||||
|
||||
@ -257,7 +257,7 @@ Mat& Mat::operator = (const Scalar& s)
|
||||
|
||||
for( size_t j = 0; j < size; j += blockSize )
|
||||
{
|
||||
size_t sz = std::min(blockSize, size - j);
|
||||
size_t sz = MIN(blockSize, size - j);
|
||||
memcpy( ptr + j, scalar, sz );
|
||||
}
|
||||
}
|
||||
@ -316,13 +316,13 @@ Mat& Mat::setTo(InputArray _value, InputArray _mask)
|
||||
static void
|
||||
flipHoriz( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size, size_t esz )
|
||||
{
|
||||
int i, j, limit = ((size.width + 1)/2)*esz;
|
||||
int i, j, limit = (int)(((size.width + 1)/2)*esz);
|
||||
AutoBuffer<int> _tab(size.width*esz);
|
||||
int* tab = _tab;
|
||||
|
||||
for( i = 0; i < size.width; i++ )
|
||||
for( size_t k = 0; k < esz; k++ )
|
||||
tab[i*esz + k] = (size.width - i - 1)*esz + k;
|
||||
tab[i*esz + k] = (int)((size.width - i - 1)*esz + k);
|
||||
|
||||
for( ; size.height--; src += sstep, dst += dstep )
|
||||
{
|
||||
|
||||
@ -3945,7 +3945,7 @@ void KDTree::findOrthoRange(InputArray _lowerBound,
|
||||
|
||||
if( _neighborsIdx.needed() )
|
||||
{
|
||||
_neighborsIdx.create(idx.size(), 1, CV_32S, -1, true);
|
||||
_neighborsIdx.create((int)idx.size(), 1, CV_32S, -1, true);
|
||||
Mat nidx = _neighborsIdx.getMat();
|
||||
Mat(nidx.size(), CV_32S, &idx[0]).copyTo(nidx);
|
||||
}
|
||||
|
||||
@ -2026,7 +2026,7 @@ void cv::fillPoly(InputOutputArray _img, InputArrayOfArrays pts,
|
||||
const Scalar& color, int lineType, int shift, Point offset)
|
||||
{
|
||||
Mat img = _img.getMat();
|
||||
size_t i, ncontours = pts.total();
|
||||
int i, ncontours = (int)pts.total();
|
||||
if( ncontours == 0 )
|
||||
return;
|
||||
AutoBuffer<Point*> _ptsptr(ncontours);
|
||||
@ -2050,7 +2050,7 @@ void cv::polylines(InputOutputArray _img, InputArrayOfArrays pts,
|
||||
int thickness, int lineType, int shift )
|
||||
{
|
||||
Mat img = _img.getMat();
|
||||
size_t i, ncontours = pts.total();
|
||||
int i, ncontours = (int)pts.total();
|
||||
if( ncontours == 0 )
|
||||
return;
|
||||
AutoBuffer<Point*> _ptsptr(ncontours);
|
||||
|
||||
@ -2713,7 +2713,7 @@ double Mat::dot(InputArray _mat) const
|
||||
{
|
||||
size_t len = total()*cn;
|
||||
if( len == (size_t)(int)len )
|
||||
return func(data, mat.data, len);
|
||||
return func(data, mat.data, (int)len);
|
||||
}
|
||||
|
||||
const Mat* arrays[] = {this, &mat, 0};
|
||||
|
||||
@ -928,7 +928,7 @@ void _InputArray::getMatVector(vector<Mat>& mv) const
|
||||
if( k == MAT )
|
||||
{
|
||||
const Mat& m = *(const Mat*)obj;
|
||||
size_t i, n = m.size[0];
|
||||
int i, n = (int)m.size[0];
|
||||
mv.resize(n);
|
||||
|
||||
for( i = 0; i < n; i++ )
|
||||
@ -940,7 +940,7 @@ void _InputArray::getMatVector(vector<Mat>& mv) const
|
||||
if( k == EXPR )
|
||||
{
|
||||
Mat m = *(const MatExpr*)obj;
|
||||
size_t i, n = m.size[0];
|
||||
int i, n = m.size[0];
|
||||
mv.resize(n);
|
||||
|
||||
for( i = 0; i < n; i++ )
|
||||
@ -980,7 +980,7 @@ void _InputArray::getMatVector(vector<Mat>& mv) const
|
||||
if( k == STD_VECTOR_VECTOR )
|
||||
{
|
||||
const vector<vector<uchar> >& vv = *(const vector<vector<uchar> >*)obj;
|
||||
size_t i, n = vv.size();
|
||||
int i, n = (int)vv.size();
|
||||
int t = CV_MAT_TYPE(flags);
|
||||
mv.resize(n);
|
||||
|
||||
@ -2795,7 +2795,7 @@ NAryMatIterator& NAryMatIterator::operator ++()
|
||||
const Mat& A = *arrays[i];
|
||||
if( !A.data )
|
||||
continue;
|
||||
int _idx = idx;
|
||||
int _idx = (int)idx;
|
||||
uchar* data = A.data;
|
||||
for( int j = iterdepth-1; j >= 0 && _idx > 0; j-- )
|
||||
{
|
||||
|
||||
@ -590,7 +590,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
|
||||
}
|
||||
|
||||
double scale = nz0 ? 1./nz0 : 0.;
|
||||
for( int k = 0; k < cn; k++ )
|
||||
for( k = 0; k < cn; k++ )
|
||||
{
|
||||
s[k] *= scale;
|
||||
sq[k] = std::sqrt(std::max(sq[k]*scale - s[k]*s[k], 0.));
|
||||
|
||||
@ -559,7 +559,8 @@ static void inRange(const Mat& src, const Mat& lb, const Mat& rb, Mat& dst)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = src.depth(), cn = src.channels();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src.depth(), cn = src.channels();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -606,7 +607,8 @@ static void inRangeS(const Mat& src, const Scalar& lb, const Scalar& rb, Mat& ds
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = src.depth(), cn = src.channels();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src.depth(), cn = src.channels();
|
||||
double lbuf[4], rbuf[4];
|
||||
int wtype = CV_MAKETYPE(depth <= CV_32S ? CV_32S : depth, cn);
|
||||
scalarToRawData(lb, lbuf, wtype, cn);
|
||||
@ -900,7 +902,8 @@ static void exp(const Mat& src, Mat& dst)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t j, total = planes[0].total()*src.channels();
|
||||
int i, nplanes = it.nplanes, depth = src.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src.depth();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -928,7 +931,8 @@ static void log(const Mat& src, Mat& dst)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t j, total = planes[0].total()*src.channels();
|
||||
int i, nplanes = it.nplanes, depth = src.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src.depth();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -1017,7 +1021,8 @@ static void cartToPolar(const Mat& mx, const Mat& my, Mat& mmag, Mat& mangle, bo
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t j, total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = mx.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = mx.depth();
|
||||
double scale = angleInDegrees ? 180/CV_PI : 1;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -1260,8 +1265,8 @@ struct MinMaxLocOp : public BaseElemWiseOp
|
||||
void saveOutput(const vector<int>& minidx, const vector<int>& maxidx,
|
||||
double minval, double maxval, Mat& dst)
|
||||
{
|
||||
size_t i, ndims = minidx.size();
|
||||
dst.create(1, (int)(ndims*2 + 2), CV_64FC1);
|
||||
int i, ndims = (int)minidx.size();
|
||||
dst.create(1, ndims*2 + 2, CV_64FC1);
|
||||
|
||||
for( i = 0; i < ndims; i++ )
|
||||
{
|
||||
|
||||
@ -170,9 +170,9 @@ static void DCT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
|
||||
w = wave.ptr<double>();
|
||||
|
||||
if( !_src.isContinuous() )
|
||||
srcstep = _src.step/_src.elemSize();
|
||||
srcstep = (int)(_src.step/_src.elemSize());
|
||||
if( !_dst.isContinuous() )
|
||||
dststep = _dst.step/_dst.elemSize();
|
||||
dststep = (int)(_dst.step/_dst.elemSize());
|
||||
|
||||
if( _src.type() == CV_32FC1 )
|
||||
{
|
||||
@ -279,10 +279,10 @@ static void convertFromCCS( const Mat& _src0, const Mat& _src1, Mat& _dst, int f
|
||||
int srcstep = cn, dststep = 1;
|
||||
|
||||
if( !_dst.isContinuous() )
|
||||
dststep = _dst.step/_dst.elemSize();
|
||||
dststep = (int)(_dst.step/_dst.elemSize());
|
||||
|
||||
if( !_src0.isContinuous() )
|
||||
srcstep = _src0.step/_src0.elemSize1();
|
||||
srcstep = (int)(_src0.step/_src0.elemSize1());
|
||||
|
||||
if( _dst.depth() == CV_32F )
|
||||
{
|
||||
|
||||
@ -1954,7 +1954,7 @@ void Core_SVDTest::prepare_to_validation( int /*test_case_idx*/ )
|
||||
}
|
||||
|
||||
w = &test_mat[TEMP][0];
|
||||
step = w->rows == 1 ? 1 : w->step1();
|
||||
step = w->rows == 1 ? 1 : (int)w->step1();
|
||||
for( i = 0; i < min_size; i++ )
|
||||
{
|
||||
double normval = 0, aii;
|
||||
|
||||
@ -618,7 +618,7 @@ void RandomizedTree::write(std::ostream &os) const
|
||||
os.write((char*)(&classes_), sizeof(classes_));
|
||||
os.write((char*)(&depth_), sizeof(depth_));
|
||||
|
||||
os.write((char*)(&nodes_[0]), nodes_.size() * sizeof(nodes_[0]));
|
||||
os.write((char*)(&nodes_[0]), (int)(nodes_.size() * sizeof(nodes_[0])));
|
||||
for (int i=0; i<num_leaves_; i++) {
|
||||
os.write((char*)posteriors_[i], classes_ * sizeof(*posteriors_[0]));
|
||||
}
|
||||
|
||||
@ -388,7 +388,8 @@ static void calculateRepeatability( const Mat& img1, const Mat& img2, const Mat&
|
||||
thresholdedOverlapMask->create( (int)keypoints1.size(), (int)keypoints2t.size(), CV_8UC1 );
|
||||
thresholdedOverlapMask->setTo( Scalar::all(0) );
|
||||
}
|
||||
size_t minCount = min( keypoints1.size(), keypoints2t.size() );
|
||||
size_t size1 = keypoints1.size(), size2 = keypoints2t.size();
|
||||
size_t minCount = MIN( size1, size2 );
|
||||
|
||||
// calculate overlap errors
|
||||
vector<SIdx> overlaps;
|
||||
|
||||
@ -1,19 +1,19 @@
|
||||
// Code generated with '$ scripts/generate_code.py src/test_pairs.txt 16'
|
||||
#define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)
|
||||
desc[0] = ((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0) ;
|
||||
desc[1] = ((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0) ;
|
||||
desc[2] = ((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0) ;
|
||||
desc[3] = ((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0) ;
|
||||
desc[4] = ((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0) ;
|
||||
desc[5] = ((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0) ;
|
||||
desc[6] = ((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0) ;
|
||||
desc[7] = ((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0) ;
|
||||
desc[8] = ((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0) ;
|
||||
desc[9] = ((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0) ;
|
||||
desc[10] = ((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0) ;
|
||||
desc[11] = ((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0) ;
|
||||
desc[12] = ((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0) ;
|
||||
desc[13] = ((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0) ;
|
||||
desc[14] = ((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0) ;
|
||||
desc[15] = ((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0) ;
|
||||
desc[0] = (uchar)(((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));
|
||||
desc[1] = (uchar)(((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0));
|
||||
desc[2] = (uchar)(((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0));
|
||||
desc[3] = (uchar)(((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0));
|
||||
desc[4] = (uchar)(((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0));
|
||||
desc[5] = (uchar)(((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0));
|
||||
desc[6] = (uchar)(((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0));
|
||||
desc[7] = (uchar)(((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0));
|
||||
desc[8] = (uchar)(((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0));
|
||||
desc[9] = (uchar)(((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0));
|
||||
desc[10] = (uchar)(((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0));
|
||||
desc[11] = (uchar)(((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0));
|
||||
desc[12] = (uchar)(((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0));
|
||||
desc[13] = (uchar)(((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0));
|
||||
desc[14] = (uchar)(((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0));
|
||||
desc[15] = (uchar)(((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0));
|
||||
#undef SMOOTHED
|
||||
|
||||
@ -1,35 +1,35 @@
|
||||
// Code generated with '$ scripts/generate_code.py src/test_pairs.txt 32'
|
||||
#define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)
|
||||
desc[0] = ((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0) ;
|
||||
desc[1] = ((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0) ;
|
||||
desc[2] = ((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0) ;
|
||||
desc[3] = ((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0) ;
|
||||
desc[4] = ((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0) ;
|
||||
desc[5] = ((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0) ;
|
||||
desc[6] = ((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0) ;
|
||||
desc[7] = ((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0) ;
|
||||
desc[8] = ((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0) ;
|
||||
desc[9] = ((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0) ;
|
||||
desc[10] = ((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0) ;
|
||||
desc[11] = ((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0) ;
|
||||
desc[12] = ((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0) ;
|
||||
desc[13] = ((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0) ;
|
||||
desc[14] = ((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0) ;
|
||||
desc[15] = ((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0) ;
|
||||
desc[16] = ((SMOOTHED(-9, 1) < SMOOTHED(-18, 0)) << 7) + ((SMOOTHED(4, 0) < SMOOTHED(1, 12)) << 6) + ((SMOOTHED(0, 9) < SMOOTHED(-14, -10)) << 5) + ((SMOOTHED(-13, -9) < SMOOTHED(-2, 6)) << 4) + ((SMOOTHED(1, 5) < SMOOTHED(10, 10)) << 3) + ((SMOOTHED(-3, -6) < SMOOTHED(-16, -5)) << 2) + ((SMOOTHED(11, 6) < SMOOTHED(-5, 0)) << 1) + ((SMOOTHED(-23, 10) < SMOOTHED(1, 2)) << 0) ;
|
||||
desc[17] = ((SMOOTHED(13, -5) < SMOOTHED(-3, 9)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-13, -5)) << 6) + ((SMOOTHED(10, 13) < SMOOTHED(-11, 8)) << 5) + ((SMOOTHED(19, 20) < SMOOTHED(-9, 2)) << 4) + ((SMOOTHED(4, -8) < SMOOTHED(0, -9)) << 3) + ((SMOOTHED(-14, 10) < SMOOTHED(15, 19)) << 2) + ((SMOOTHED(-14, -12) < SMOOTHED(-10, -3)) << 1) + ((SMOOTHED(-23, -3) < SMOOTHED(17, -2)) << 0) ;
|
||||
desc[18] = ((SMOOTHED(-3, -11) < SMOOTHED(6, -14)) << 7) + ((SMOOTHED(19, -2) < SMOOTHED(-4, 2)) << 6) + ((SMOOTHED(-5, 5) < SMOOTHED(3, -13)) << 5) + ((SMOOTHED(2, -2) < SMOOTHED(-5, 4)) << 4) + ((SMOOTHED(17, 4) < SMOOTHED(17, -11)) << 3) + ((SMOOTHED(-7, -2) < SMOOTHED(1, 23)) << 2) + ((SMOOTHED(8, 13) < SMOOTHED(1, -16)) << 1) + ((SMOOTHED(-13, -5) < SMOOTHED(1, -17)) << 0) ;
|
||||
desc[19] = ((SMOOTHED(4, 6) < SMOOTHED(-8, -3)) << 7) + ((SMOOTHED(-5, -9) < SMOOTHED(-2, -10)) << 6) + ((SMOOTHED(-9, 0) < SMOOTHED(-7, -2)) << 5) + ((SMOOTHED(5, 0) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-4, -16) < SMOOTHED(6, 3)) << 3) + ((SMOOTHED(2, -15) < SMOOTHED(-2, 12)) << 2) + ((SMOOTHED(4, -1) < SMOOTHED(6, 2)) << 1) + ((SMOOTHED(1, 1) < SMOOTHED(-2, -8)) << 0) ;
|
||||
desc[20] = ((SMOOTHED(-2, 12) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, 8) < SMOOTHED(-9, 9)) << 6) + ((SMOOTHED(2, -10) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-4, 10) < SMOOTHED(-9, 4)) << 4) + ((SMOOTHED(6, 12) < SMOOTHED(2, 5)) << 3) + ((SMOOTHED(-3, -8) < SMOOTHED(0, 5)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-7, 2)) << 1) + ((SMOOTHED(-1, -10) < SMOOTHED(7, -18)) << 0) ;
|
||||
desc[21] = ((SMOOTHED(-1, 8) < SMOOTHED(-9, -10)) << 7) + ((SMOOTHED(-23, -1) < SMOOTHED(6, 2)) << 6) + ((SMOOTHED(-5, -3) < SMOOTHED(3, 2)) << 5) + ((SMOOTHED(0, 11) < SMOOTHED(-4, -7)) << 4) + ((SMOOTHED(15, 2) < SMOOTHED(-10, -3)) << 3) + ((SMOOTHED(-20, -8) < SMOOTHED(-13, 3)) << 2) + ((SMOOTHED(-19, -12) < SMOOTHED(5, -11)) << 1) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 0) ;
|
||||
desc[22] = ((SMOOTHED(7, 4) < SMOOTHED(-12, 0)) << 7) + ((SMOOTHED(5, -1) < SMOOTHED(-14, -6)) << 6) + ((SMOOTHED(-4, 11) < SMOOTHED(0, -4)) << 5) + ((SMOOTHED(3, 10) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(13, 21) < SMOOTHED(-11, 6)) << 3) + ((SMOOTHED(-12, 24) < SMOOTHED(-7, -4)) << 2) + ((SMOOTHED(4, 16) < SMOOTHED(3, -14)) << 1) + ((SMOOTHED(-3, 5) < SMOOTHED(-7, -12)) << 0) ;
|
||||
desc[23] = ((SMOOTHED(0, -4) < SMOOTHED(7, -5)) << 7) + ((SMOOTHED(-17, -9) < SMOOTHED(13, -7)) << 6) + ((SMOOTHED(22, -6) < SMOOTHED(-11, 5)) << 5) + ((SMOOTHED(2, -8) < SMOOTHED(23, -11)) << 4) + ((SMOOTHED(7, -10) < SMOOTHED(-1, 14)) << 3) + ((SMOOTHED(-3, -10) < SMOOTHED(8, 3)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-6, 0)) << 1) + ((SMOOTHED(-7, -21) < SMOOTHED(6, -14)) << 0) ;
|
||||
desc[24] = ((SMOOTHED(18, 19) < SMOOTHED(-4, -6)) << 7) + ((SMOOTHED(10, 7) < SMOOTHED(-1, -4)) << 6) + ((SMOOTHED(-1, 21) < SMOOTHED(1, -5)) << 5) + ((SMOOTHED(-10, 6) < SMOOTHED(-11, -2)) << 4) + ((SMOOTHED(18, -3) < SMOOTHED(-1, 7)) << 3) + ((SMOOTHED(-3, -9) < SMOOTHED(-5, 10)) << 2) + ((SMOOTHED(-13, 14) < SMOOTHED(17, -3)) << 1) + ((SMOOTHED(11, -19) < SMOOTHED(-1, -18)) << 0) ;
|
||||
desc[25] = ((SMOOTHED(8, -2) < SMOOTHED(-18, -23)) << 7) + ((SMOOTHED(0, -5) < SMOOTHED(-2, -9)) << 6) + ((SMOOTHED(-4, -11) < SMOOTHED(2, -8)) << 5) + ((SMOOTHED(14, 6) < SMOOTHED(-3, -6)) << 4) + ((SMOOTHED(-3, 0) < SMOOTHED(-15, 0)) << 3) + ((SMOOTHED(-9, 4) < SMOOTHED(-15, -9)) << 2) + ((SMOOTHED(-1, 11) < SMOOTHED(3, 11)) << 1) + ((SMOOTHED(-10, -16) < SMOOTHED(-7, 7)) << 0) ;
|
||||
desc[26] = ((SMOOTHED(-2, -10) < SMOOTHED(-10, -2)) << 7) + ((SMOOTHED(-5, -3) < SMOOTHED(5, -23)) << 6) + ((SMOOTHED(13, -8) < SMOOTHED(-15, -11)) << 5) + ((SMOOTHED(-15, 11) < SMOOTHED(6, -6)) << 4) + ((SMOOTHED(-16, -3) < SMOOTHED(-2, 2)) << 3) + ((SMOOTHED(6, 12) < SMOOTHED(-16, 24)) << 2) + ((SMOOTHED(-10, 0) < SMOOTHED(8, 11)) << 1) + ((SMOOTHED(-7, 7) < SMOOTHED(-19, -7)) << 0) ;
|
||||
desc[27] = ((SMOOTHED(5, 16) < SMOOTHED(9, -3)) << 7) + ((SMOOTHED(9, 7) < SMOOTHED(-7, -16)) << 6) + ((SMOOTHED(3, 2) < SMOOTHED(-10, 9)) << 5) + ((SMOOTHED(21, 1) < SMOOTHED(8, 7)) << 4) + ((SMOOTHED(7, 0) < SMOOTHED(1, 17)) << 3) + ((SMOOTHED(-8, 12) < SMOOTHED(9, 6)) << 2) + ((SMOOTHED(11, -7) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(19, 0) < SMOOTHED(9, 3)) << 0) ;
|
||||
desc[28] = ((SMOOTHED(1, -7) < SMOOTHED(-5, -11)) << 7) + ((SMOOTHED(0, 8) < SMOOTHED(-2, 14)) << 6) + ((SMOOTHED(12, -2) < SMOOTHED(-15, -6)) << 5) + ((SMOOTHED(4, 12) < SMOOTHED(0, -21)) << 4) + ((SMOOTHED(17, -4) < SMOOTHED(-6, -7)) << 3) + ((SMOOTHED(-10, -9) < SMOOTHED(-14, -7)) << 2) + ((SMOOTHED(-15, -10) < SMOOTHED(-15, -14)) << 1) + ((SMOOTHED(-7, -5) < SMOOTHED(5, -12)) << 0) ;
|
||||
desc[29] = ((SMOOTHED(-4, 0) < SMOOTHED(15, -4)) << 7) + ((SMOOTHED(5, 2) < SMOOTHED(-6, -23)) << 6) + ((SMOOTHED(-4, -21) < SMOOTHED(-6, 4)) << 5) + ((SMOOTHED(-10, 5) < SMOOTHED(-15, 6)) << 4) + ((SMOOTHED(4, -3) < SMOOTHED(-1, 5)) << 3) + ((SMOOTHED(-4, 19) < SMOOTHED(-23, -4)) << 2) + ((SMOOTHED(-4, 17) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(1, 12) < SMOOTHED(4, -14)) << 0) ;
|
||||
desc[30] = ((SMOOTHED(-11, -6) < SMOOTHED(-20, 10)) << 7) + ((SMOOTHED(4, 5) < SMOOTHED(3, 20)) << 6) + ((SMOOTHED(-8, -20) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-19, 9) < SMOOTHED(9, -3)) << 4) + ((SMOOTHED(18, 15) < SMOOTHED(11, -4)) << 3) + ((SMOOTHED(12, 16) < SMOOTHED(8, 7)) << 2) + ((SMOOTHED(-14, -8) < SMOOTHED(-3, 9)) << 1) + ((SMOOTHED(-6, 0) < SMOOTHED(2, -4)) << 0) ;
|
||||
desc[31] = ((SMOOTHED(1, -10) < SMOOTHED(-1, 2)) << 7) + ((SMOOTHED(8, -7) < SMOOTHED(-6, 18)) << 6) + ((SMOOTHED(9, 12) < SMOOTHED(-7, -23)) << 5) + ((SMOOTHED(8, -6) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-9, 6) < SMOOTHED(-12, -7)) << 3) + ((SMOOTHED(-1, -2) < SMOOTHED(-7, 2)) << 2) + ((SMOOTHED(9, 9) < SMOOTHED(7, 15)) << 1) + ((SMOOTHED(6, 2) < SMOOTHED(-6, 6)) << 0) ;
|
||||
desc[0] = (uchar)(((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));
|
||||
desc[1] = (uchar)(((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0));
|
||||
desc[2] = (uchar)(((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0));
|
||||
desc[3] = (uchar)(((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0));
|
||||
desc[4] = (uchar)(((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0));
|
||||
desc[5] = (uchar)(((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0));
|
||||
desc[6] = (uchar)(((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0));
|
||||
desc[7] = (uchar)(((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0));
|
||||
desc[8] = (uchar)(((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0));
|
||||
desc[9] = (uchar)(((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0));
|
||||
desc[10] = (uchar)(((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0));
|
||||
desc[11] = (uchar)(((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0));
|
||||
desc[12] = (uchar)(((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0));
|
||||
desc[13] = (uchar)(((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0));
|
||||
desc[14] = (uchar)(((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0));
|
||||
desc[15] = (uchar)(((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0));
|
||||
desc[16] = (uchar)(((SMOOTHED(-9, 1) < SMOOTHED(-18, 0)) << 7) + ((SMOOTHED(4, 0) < SMOOTHED(1, 12)) << 6) + ((SMOOTHED(0, 9) < SMOOTHED(-14, -10)) << 5) + ((SMOOTHED(-13, -9) < SMOOTHED(-2, 6)) << 4) + ((SMOOTHED(1, 5) < SMOOTHED(10, 10)) << 3) + ((SMOOTHED(-3, -6) < SMOOTHED(-16, -5)) << 2) + ((SMOOTHED(11, 6) < SMOOTHED(-5, 0)) << 1) + ((SMOOTHED(-23, 10) < SMOOTHED(1, 2)) << 0));
|
||||
desc[17] = (uchar)(((SMOOTHED(13, -5) < SMOOTHED(-3, 9)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-13, -5)) << 6) + ((SMOOTHED(10, 13) < SMOOTHED(-11, 8)) << 5) + ((SMOOTHED(19, 20) < SMOOTHED(-9, 2)) << 4) + ((SMOOTHED(4, -8) < SMOOTHED(0, -9)) << 3) + ((SMOOTHED(-14, 10) < SMOOTHED(15, 19)) << 2) + ((SMOOTHED(-14, -12) < SMOOTHED(-10, -3)) << 1) + ((SMOOTHED(-23, -3) < SMOOTHED(17, -2)) << 0));
|
||||
desc[18] = (uchar)(((SMOOTHED(-3, -11) < SMOOTHED(6, -14)) << 7) + ((SMOOTHED(19, -2) < SMOOTHED(-4, 2)) << 6) + ((SMOOTHED(-5, 5) < SMOOTHED(3, -13)) << 5) + ((SMOOTHED(2, -2) < SMOOTHED(-5, 4)) << 4) + ((SMOOTHED(17, 4) < SMOOTHED(17, -11)) << 3) + ((SMOOTHED(-7, -2) < SMOOTHED(1, 23)) << 2) + ((SMOOTHED(8, 13) < SMOOTHED(1, -16)) << 1) + ((SMOOTHED(-13, -5) < SMOOTHED(1, -17)) << 0));
|
||||
desc[19] = (uchar)(((SMOOTHED(4, 6) < SMOOTHED(-8, -3)) << 7) + ((SMOOTHED(-5, -9) < SMOOTHED(-2, -10)) << 6) + ((SMOOTHED(-9, 0) < SMOOTHED(-7, -2)) << 5) + ((SMOOTHED(5, 0) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-4, -16) < SMOOTHED(6, 3)) << 3) + ((SMOOTHED(2, -15) < SMOOTHED(-2, 12)) << 2) + ((SMOOTHED(4, -1) < SMOOTHED(6, 2)) << 1) + ((SMOOTHED(1, 1) < SMOOTHED(-2, -8)) << 0));
|
||||
desc[20] = (uchar)(((SMOOTHED(-2, 12) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, 8) < SMOOTHED(-9, 9)) << 6) + ((SMOOTHED(2, -10) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-4, 10) < SMOOTHED(-9, 4)) << 4) + ((SMOOTHED(6, 12) < SMOOTHED(2, 5)) << 3) + ((SMOOTHED(-3, -8) < SMOOTHED(0, 5)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-7, 2)) << 1) + ((SMOOTHED(-1, -10) < SMOOTHED(7, -18)) << 0));
|
||||
desc[21] = (uchar)(((SMOOTHED(-1, 8) < SMOOTHED(-9, -10)) << 7) + ((SMOOTHED(-23, -1) < SMOOTHED(6, 2)) << 6) + ((SMOOTHED(-5, -3) < SMOOTHED(3, 2)) << 5) + ((SMOOTHED(0, 11) < SMOOTHED(-4, -7)) << 4) + ((SMOOTHED(15, 2) < SMOOTHED(-10, -3)) << 3) + ((SMOOTHED(-20, -8) < SMOOTHED(-13, 3)) << 2) + ((SMOOTHED(-19, -12) < SMOOTHED(5, -11)) << 1) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 0));
|
||||
desc[22] = (uchar)(((SMOOTHED(7, 4) < SMOOTHED(-12, 0)) << 7) + ((SMOOTHED(5, -1) < SMOOTHED(-14, -6)) << 6) + ((SMOOTHED(-4, 11) < SMOOTHED(0, -4)) << 5) + ((SMOOTHED(3, 10) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(13, 21) < SMOOTHED(-11, 6)) << 3) + ((SMOOTHED(-12, 24) < SMOOTHED(-7, -4)) << 2) + ((SMOOTHED(4, 16) < SMOOTHED(3, -14)) << 1) + ((SMOOTHED(-3, 5) < SMOOTHED(-7, -12)) << 0));
|
||||
desc[23] = (uchar)(((SMOOTHED(0, -4) < SMOOTHED(7, -5)) << 7) + ((SMOOTHED(-17, -9) < SMOOTHED(13, -7)) << 6) + ((SMOOTHED(22, -6) < SMOOTHED(-11, 5)) << 5) + ((SMOOTHED(2, -8) < SMOOTHED(23, -11)) << 4) + ((SMOOTHED(7, -10) < SMOOTHED(-1, 14)) << 3) + ((SMOOTHED(-3, -10) < SMOOTHED(8, 3)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-6, 0)) << 1) + ((SMOOTHED(-7, -21) < SMOOTHED(6, -14)) << 0));
|
||||
desc[24] = (uchar)(((SMOOTHED(18, 19) < SMOOTHED(-4, -6)) << 7) + ((SMOOTHED(10, 7) < SMOOTHED(-1, -4)) << 6) + ((SMOOTHED(-1, 21) < SMOOTHED(1, -5)) << 5) + ((SMOOTHED(-10, 6) < SMOOTHED(-11, -2)) << 4) + ((SMOOTHED(18, -3) < SMOOTHED(-1, 7)) << 3) + ((SMOOTHED(-3, -9) < SMOOTHED(-5, 10)) << 2) + ((SMOOTHED(-13, 14) < SMOOTHED(17, -3)) << 1) + ((SMOOTHED(11, -19) < SMOOTHED(-1, -18)) << 0));
|
||||
desc[25] = (uchar)(((SMOOTHED(8, -2) < SMOOTHED(-18, -23)) << 7) + ((SMOOTHED(0, -5) < SMOOTHED(-2, -9)) << 6) + ((SMOOTHED(-4, -11) < SMOOTHED(2, -8)) << 5) + ((SMOOTHED(14, 6) < SMOOTHED(-3, -6)) << 4) + ((SMOOTHED(-3, 0) < SMOOTHED(-15, 0)) << 3) + ((SMOOTHED(-9, 4) < SMOOTHED(-15, -9)) << 2) + ((SMOOTHED(-1, 11) < SMOOTHED(3, 11)) << 1) + ((SMOOTHED(-10, -16) < SMOOTHED(-7, 7)) << 0));
|
||||
desc[26] = (uchar)(((SMOOTHED(-2, -10) < SMOOTHED(-10, -2)) << 7) + ((SMOOTHED(-5, -3) < SMOOTHED(5, -23)) << 6) + ((SMOOTHED(13, -8) < SMOOTHED(-15, -11)) << 5) + ((SMOOTHED(-15, 11) < SMOOTHED(6, -6)) << 4) + ((SMOOTHED(-16, -3) < SMOOTHED(-2, 2)) << 3) + ((SMOOTHED(6, 12) < SMOOTHED(-16, 24)) << 2) + ((SMOOTHED(-10, 0) < SMOOTHED(8, 11)) << 1) + ((SMOOTHED(-7, 7) < SMOOTHED(-19, -7)) << 0));
|
||||
desc[27] = (uchar)(((SMOOTHED(5, 16) < SMOOTHED(9, -3)) << 7) + ((SMOOTHED(9, 7) < SMOOTHED(-7, -16)) << 6) + ((SMOOTHED(3, 2) < SMOOTHED(-10, 9)) << 5) + ((SMOOTHED(21, 1) < SMOOTHED(8, 7)) << 4) + ((SMOOTHED(7, 0) < SMOOTHED(1, 17)) << 3) + ((SMOOTHED(-8, 12) < SMOOTHED(9, 6)) << 2) + ((SMOOTHED(11, -7) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(19, 0) < SMOOTHED(9, 3)) << 0));
|
||||
desc[28] = (uchar)(((SMOOTHED(1, -7) < SMOOTHED(-5, -11)) << 7) + ((SMOOTHED(0, 8) < SMOOTHED(-2, 14)) << 6) + ((SMOOTHED(12, -2) < SMOOTHED(-15, -6)) << 5) + ((SMOOTHED(4, 12) < SMOOTHED(0, -21)) << 4) + ((SMOOTHED(17, -4) < SMOOTHED(-6, -7)) << 3) + ((SMOOTHED(-10, -9) < SMOOTHED(-14, -7)) << 2) + ((SMOOTHED(-15, -10) < SMOOTHED(-15, -14)) << 1) + ((SMOOTHED(-7, -5) < SMOOTHED(5, -12)) << 0));
|
||||
desc[29] = (uchar)(((SMOOTHED(-4, 0) < SMOOTHED(15, -4)) << 7) + ((SMOOTHED(5, 2) < SMOOTHED(-6, -23)) << 6) + ((SMOOTHED(-4, -21) < SMOOTHED(-6, 4)) << 5) + ((SMOOTHED(-10, 5) < SMOOTHED(-15, 6)) << 4) + ((SMOOTHED(4, -3) < SMOOTHED(-1, 5)) << 3) + ((SMOOTHED(-4, 19) < SMOOTHED(-23, -4)) << 2) + ((SMOOTHED(-4, 17) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(1, 12) < SMOOTHED(4, -14)) << 0));
|
||||
desc[30] = (uchar)(((SMOOTHED(-11, -6) < SMOOTHED(-20, 10)) << 7) + ((SMOOTHED(4, 5) < SMOOTHED(3, 20)) << 6) + ((SMOOTHED(-8, -20) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-19, 9) < SMOOTHED(9, -3)) << 4) + ((SMOOTHED(18, 15) < SMOOTHED(11, -4)) << 3) + ((SMOOTHED(12, 16) < SMOOTHED(8, 7)) << 2) + ((SMOOTHED(-14, -8) < SMOOTHED(-3, 9)) << 1) + ((SMOOTHED(-6, 0) < SMOOTHED(2, -4)) << 0));
|
||||
desc[31] = (uchar)(((SMOOTHED(1, -10) < SMOOTHED(-1, 2)) << 7) + ((SMOOTHED(8, -7) < SMOOTHED(-6, 18)) << 6) + ((SMOOTHED(9, 12) < SMOOTHED(-7, -23)) << 5) + ((SMOOTHED(8, -6) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-9, 6) < SMOOTHED(-12, -7)) << 3) + ((SMOOTHED(-1, -2) < SMOOTHED(-7, 2)) << 2) + ((SMOOTHED(9, 9) < SMOOTHED(7, 15)) << 1) + ((SMOOTHED(6, 2) < SMOOTHED(-6, 6)) << 0));
|
||||
#undef SMOOTHED
|
||||
|
||||
@ -1,67 +1,67 @@
|
||||
// Code generated with '$ scripts/generate_code.py src/test_pairs.txt 64'
|
||||
#define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)
|
||||
desc[0] = ((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0) ;
|
||||
desc[1] = ((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0) ;
|
||||
desc[2] = ((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0) ;
|
||||
desc[3] = ((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0) ;
|
||||
desc[4] = ((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0) ;
|
||||
desc[5] = ((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0) ;
|
||||
desc[6] = ((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0) ;
|
||||
desc[7] = ((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0) ;
|
||||
desc[8] = ((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0) ;
|
||||
desc[9] = ((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0) ;
|
||||
desc[10] = ((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0) ;
|
||||
desc[11] = ((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0) ;
|
||||
desc[12] = ((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0) ;
|
||||
desc[13] = ((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0) ;
|
||||
desc[14] = ((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0) ;
|
||||
desc[15] = ((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0) ;
|
||||
desc[16] = ((SMOOTHED(-9, 1) < SMOOTHED(-18, 0)) << 7) + ((SMOOTHED(4, 0) < SMOOTHED(1, 12)) << 6) + ((SMOOTHED(0, 9) < SMOOTHED(-14, -10)) << 5) + ((SMOOTHED(-13, -9) < SMOOTHED(-2, 6)) << 4) + ((SMOOTHED(1, 5) < SMOOTHED(10, 10)) << 3) + ((SMOOTHED(-3, -6) < SMOOTHED(-16, -5)) << 2) + ((SMOOTHED(11, 6) < SMOOTHED(-5, 0)) << 1) + ((SMOOTHED(-23, 10) < SMOOTHED(1, 2)) << 0) ;
|
||||
desc[17] = ((SMOOTHED(13, -5) < SMOOTHED(-3, 9)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-13, -5)) << 6) + ((SMOOTHED(10, 13) < SMOOTHED(-11, 8)) << 5) + ((SMOOTHED(19, 20) < SMOOTHED(-9, 2)) << 4) + ((SMOOTHED(4, -8) < SMOOTHED(0, -9)) << 3) + ((SMOOTHED(-14, 10) < SMOOTHED(15, 19)) << 2) + ((SMOOTHED(-14, -12) < SMOOTHED(-10, -3)) << 1) + ((SMOOTHED(-23, -3) < SMOOTHED(17, -2)) << 0) ;
|
||||
desc[18] = ((SMOOTHED(-3, -11) < SMOOTHED(6, -14)) << 7) + ((SMOOTHED(19, -2) < SMOOTHED(-4, 2)) << 6) + ((SMOOTHED(-5, 5) < SMOOTHED(3, -13)) << 5) + ((SMOOTHED(2, -2) < SMOOTHED(-5, 4)) << 4) + ((SMOOTHED(17, 4) < SMOOTHED(17, -11)) << 3) + ((SMOOTHED(-7, -2) < SMOOTHED(1, 23)) << 2) + ((SMOOTHED(8, 13) < SMOOTHED(1, -16)) << 1) + ((SMOOTHED(-13, -5) < SMOOTHED(1, -17)) << 0) ;
|
||||
desc[19] = ((SMOOTHED(4, 6) < SMOOTHED(-8, -3)) << 7) + ((SMOOTHED(-5, -9) < SMOOTHED(-2, -10)) << 6) + ((SMOOTHED(-9, 0) < SMOOTHED(-7, -2)) << 5) + ((SMOOTHED(5, 0) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-4, -16) < SMOOTHED(6, 3)) << 3) + ((SMOOTHED(2, -15) < SMOOTHED(-2, 12)) << 2) + ((SMOOTHED(4, -1) < SMOOTHED(6, 2)) << 1) + ((SMOOTHED(1, 1) < SMOOTHED(-2, -8)) << 0) ;
|
||||
desc[20] = ((SMOOTHED(-2, 12) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, 8) < SMOOTHED(-9, 9)) << 6) + ((SMOOTHED(2, -10) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-4, 10) < SMOOTHED(-9, 4)) << 4) + ((SMOOTHED(6, 12) < SMOOTHED(2, 5)) << 3) + ((SMOOTHED(-3, -8) < SMOOTHED(0, 5)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-7, 2)) << 1) + ((SMOOTHED(-1, -10) < SMOOTHED(7, -18)) << 0) ;
|
||||
desc[21] = ((SMOOTHED(-1, 8) < SMOOTHED(-9, -10)) << 7) + ((SMOOTHED(-23, -1) < SMOOTHED(6, 2)) << 6) + ((SMOOTHED(-5, -3) < SMOOTHED(3, 2)) << 5) + ((SMOOTHED(0, 11) < SMOOTHED(-4, -7)) << 4) + ((SMOOTHED(15, 2) < SMOOTHED(-10, -3)) << 3) + ((SMOOTHED(-20, -8) < SMOOTHED(-13, 3)) << 2) + ((SMOOTHED(-19, -12) < SMOOTHED(5, -11)) << 1) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 0) ;
|
||||
desc[22] = ((SMOOTHED(7, 4) < SMOOTHED(-12, 0)) << 7) + ((SMOOTHED(5, -1) < SMOOTHED(-14, -6)) << 6) + ((SMOOTHED(-4, 11) < SMOOTHED(0, -4)) << 5) + ((SMOOTHED(3, 10) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(13, 21) < SMOOTHED(-11, 6)) << 3) + ((SMOOTHED(-12, 24) < SMOOTHED(-7, -4)) << 2) + ((SMOOTHED(4, 16) < SMOOTHED(3, -14)) << 1) + ((SMOOTHED(-3, 5) < SMOOTHED(-7, -12)) << 0) ;
|
||||
desc[23] = ((SMOOTHED(0, -4) < SMOOTHED(7, -5)) << 7) + ((SMOOTHED(-17, -9) < SMOOTHED(13, -7)) << 6) + ((SMOOTHED(22, -6) < SMOOTHED(-11, 5)) << 5) + ((SMOOTHED(2, -8) < SMOOTHED(23, -11)) << 4) + ((SMOOTHED(7, -10) < SMOOTHED(-1, 14)) << 3) + ((SMOOTHED(-3, -10) < SMOOTHED(8, 3)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-6, 0)) << 1) + ((SMOOTHED(-7, -21) < SMOOTHED(6, -14)) << 0) ;
|
||||
desc[24] = ((SMOOTHED(18, 19) < SMOOTHED(-4, -6)) << 7) + ((SMOOTHED(10, 7) < SMOOTHED(-1, -4)) << 6) + ((SMOOTHED(-1, 21) < SMOOTHED(1, -5)) << 5) + ((SMOOTHED(-10, 6) < SMOOTHED(-11, -2)) << 4) + ((SMOOTHED(18, -3) < SMOOTHED(-1, 7)) << 3) + ((SMOOTHED(-3, -9) < SMOOTHED(-5, 10)) << 2) + ((SMOOTHED(-13, 14) < SMOOTHED(17, -3)) << 1) + ((SMOOTHED(11, -19) < SMOOTHED(-1, -18)) << 0) ;
|
||||
desc[25] = ((SMOOTHED(8, -2) < SMOOTHED(-18, -23)) << 7) + ((SMOOTHED(0, -5) < SMOOTHED(-2, -9)) << 6) + ((SMOOTHED(-4, -11) < SMOOTHED(2, -8)) << 5) + ((SMOOTHED(14, 6) < SMOOTHED(-3, -6)) << 4) + ((SMOOTHED(-3, 0) < SMOOTHED(-15, 0)) << 3) + ((SMOOTHED(-9, 4) < SMOOTHED(-15, -9)) << 2) + ((SMOOTHED(-1, 11) < SMOOTHED(3, 11)) << 1) + ((SMOOTHED(-10, -16) < SMOOTHED(-7, 7)) << 0) ;
|
||||
desc[26] = ((SMOOTHED(-2, -10) < SMOOTHED(-10, -2)) << 7) + ((SMOOTHED(-5, -3) < SMOOTHED(5, -23)) << 6) + ((SMOOTHED(13, -8) < SMOOTHED(-15, -11)) << 5) + ((SMOOTHED(-15, 11) < SMOOTHED(6, -6)) << 4) + ((SMOOTHED(-16, -3) < SMOOTHED(-2, 2)) << 3) + ((SMOOTHED(6, 12) < SMOOTHED(-16, 24)) << 2) + ((SMOOTHED(-10, 0) < SMOOTHED(8, 11)) << 1) + ((SMOOTHED(-7, 7) < SMOOTHED(-19, -7)) << 0) ;
|
||||
desc[27] = ((SMOOTHED(5, 16) < SMOOTHED(9, -3)) << 7) + ((SMOOTHED(9, 7) < SMOOTHED(-7, -16)) << 6) + ((SMOOTHED(3, 2) < SMOOTHED(-10, 9)) << 5) + ((SMOOTHED(21, 1) < SMOOTHED(8, 7)) << 4) + ((SMOOTHED(7, 0) < SMOOTHED(1, 17)) << 3) + ((SMOOTHED(-8, 12) < SMOOTHED(9, 6)) << 2) + ((SMOOTHED(11, -7) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(19, 0) < SMOOTHED(9, 3)) << 0) ;
|
||||
desc[28] = ((SMOOTHED(1, -7) < SMOOTHED(-5, -11)) << 7) + ((SMOOTHED(0, 8) < SMOOTHED(-2, 14)) << 6) + ((SMOOTHED(12, -2) < SMOOTHED(-15, -6)) << 5) + ((SMOOTHED(4, 12) < SMOOTHED(0, -21)) << 4) + ((SMOOTHED(17, -4) < SMOOTHED(-6, -7)) << 3) + ((SMOOTHED(-10, -9) < SMOOTHED(-14, -7)) << 2) + ((SMOOTHED(-15, -10) < SMOOTHED(-15, -14)) << 1) + ((SMOOTHED(-7, -5) < SMOOTHED(5, -12)) << 0) ;
|
||||
desc[29] = ((SMOOTHED(-4, 0) < SMOOTHED(15, -4)) << 7) + ((SMOOTHED(5, 2) < SMOOTHED(-6, -23)) << 6) + ((SMOOTHED(-4, -21) < SMOOTHED(-6, 4)) << 5) + ((SMOOTHED(-10, 5) < SMOOTHED(-15, 6)) << 4) + ((SMOOTHED(4, -3) < SMOOTHED(-1, 5)) << 3) + ((SMOOTHED(-4, 19) < SMOOTHED(-23, -4)) << 2) + ((SMOOTHED(-4, 17) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(1, 12) < SMOOTHED(4, -14)) << 0) ;
|
||||
desc[30] = ((SMOOTHED(-11, -6) < SMOOTHED(-20, 10)) << 7) + ((SMOOTHED(4, 5) < SMOOTHED(3, 20)) << 6) + ((SMOOTHED(-8, -20) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-19, 9) < SMOOTHED(9, -3)) << 4) + ((SMOOTHED(18, 15) < SMOOTHED(11, -4)) << 3) + ((SMOOTHED(12, 16) < SMOOTHED(8, 7)) << 2) + ((SMOOTHED(-14, -8) < SMOOTHED(-3, 9)) << 1) + ((SMOOTHED(-6, 0) < SMOOTHED(2, -4)) << 0) ;
|
||||
desc[31] = ((SMOOTHED(1, -10) < SMOOTHED(-1, 2)) << 7) + ((SMOOTHED(8, -7) < SMOOTHED(-6, 18)) << 6) + ((SMOOTHED(9, 12) < SMOOTHED(-7, -23)) << 5) + ((SMOOTHED(8, -6) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-9, 6) < SMOOTHED(-12, -7)) << 3) + ((SMOOTHED(-1, -2) < SMOOTHED(-7, 2)) << 2) + ((SMOOTHED(9, 9) < SMOOTHED(7, 15)) << 1) + ((SMOOTHED(6, 2) < SMOOTHED(-6, 6)) << 0) ;
|
||||
desc[32] = ((SMOOTHED(16, 12) < SMOOTHED(0, 19)) << 7) + ((SMOOTHED(4, 3) < SMOOTHED(6, 0)) << 6) + ((SMOOTHED(-2, -1) < SMOOTHED(2, 17)) << 5) + ((SMOOTHED(8, 1) < SMOOTHED(3, 1)) << 4) + ((SMOOTHED(-12, -1) < SMOOTHED(-11, 0)) << 3) + ((SMOOTHED(-11, 2) < SMOOTHED(7, 9)) << 2) + ((SMOOTHED(-1, 3) < SMOOTHED(-19, 4)) << 1) + ((SMOOTHED(-1, -11) < SMOOTHED(-1, 3)) << 0) ;
|
||||
desc[33] = ((SMOOTHED(1, -10) < SMOOTHED(-10, -4)) << 7) + ((SMOOTHED(-2, 3) < SMOOTHED(6, 11)) << 6) + ((SMOOTHED(3, 7) < SMOOTHED(-9, -8)) << 5) + ((SMOOTHED(24, -14) < SMOOTHED(-2, -10)) << 4) + ((SMOOTHED(-3, -3) < SMOOTHED(-18, -6)) << 3) + ((SMOOTHED(-13, -10) < SMOOTHED(-7, -1)) << 2) + ((SMOOTHED(2, -7) < SMOOTHED(9, -6)) << 1) + ((SMOOTHED(2, -4) < SMOOTHED(6, -13)) << 0) ;
|
||||
desc[34] = ((SMOOTHED(4, -4) < SMOOTHED(-2, 3)) << 7) + ((SMOOTHED(-4, 2) < SMOOTHED(9, 13)) << 6) + ((SMOOTHED(-11, 5) < SMOOTHED(-6, -11)) << 5) + ((SMOOTHED(4, -2) < SMOOTHED(11, -9)) << 4) + ((SMOOTHED(-19, 0) < SMOOTHED(-23, -5)) << 3) + ((SMOOTHED(-5, -7) < SMOOTHED(-3, -6)) << 2) + ((SMOOTHED(-6, -4) < SMOOTHED(12, 14)) << 1) + ((SMOOTHED(12, -11) < SMOOTHED(-8, -16)) << 0) ;
|
||||
desc[35] = ((SMOOTHED(-21, 15) < SMOOTHED(-12, 6)) << 7) + ((SMOOTHED(-2, -1) < SMOOTHED(-8, 16)) << 6) + ((SMOOTHED(6, -1) < SMOOTHED(-8, -2)) << 5) + ((SMOOTHED(1, -1) < SMOOTHED(-9, 8)) << 4) + ((SMOOTHED(3, -4) < SMOOTHED(-2, -2)) << 3) + ((SMOOTHED(-7, 0) < SMOOTHED(4, -8)) << 2) + ((SMOOTHED(11, -11) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(2, 3) < SMOOTHED(11, 7)) << 0) ;
|
||||
desc[36] = ((SMOOTHED(-7, -4) < SMOOTHED(-9, -6)) << 7) + ((SMOOTHED(3, -7) < SMOOTHED(-5, 0)) << 6) + ((SMOOTHED(3, -7) < SMOOTHED(-10, -5)) << 5) + ((SMOOTHED(-3, -1) < SMOOTHED(8, -10)) << 4) + ((SMOOTHED(0, 8) < SMOOTHED(5, 1)) << 3) + ((SMOOTHED(9, 0) < SMOOTHED(1, 16)) << 2) + ((SMOOTHED(8, 4) < SMOOTHED(-11, -3)) << 1) + ((SMOOTHED(-15, 9) < SMOOTHED(8, 17)) << 0) ;
|
||||
desc[37] = ((SMOOTHED(0, 2) < SMOOTHED(-9, 17)) << 7) + ((SMOOTHED(-6, -11) < SMOOTHED(-10, -3)) << 6) + ((SMOOTHED(1, 1) < SMOOTHED(15, -8)) << 5) + ((SMOOTHED(-12, -13) < SMOOTHED(-2, 4)) << 4) + ((SMOOTHED(-6, 4) < SMOOTHED(-6, -10)) << 3) + ((SMOOTHED(5, -7) < SMOOTHED(7, -5)) << 2) + ((SMOOTHED(10, 6) < SMOOTHED(8, 9)) << 1) + ((SMOOTHED(-5, 7) < SMOOTHED(-18, -3)) << 0) ;
|
||||
desc[38] = ((SMOOTHED(-6, 3) < SMOOTHED(5, 4)) << 7) + ((SMOOTHED(-10, -13) < SMOOTHED(-5, -3)) << 6) + ((SMOOTHED(-11, 2) < SMOOTHED(-16, 0)) << 5) + ((SMOOTHED(7, -21) < SMOOTHED(-5, -13)) << 4) + ((SMOOTHED(-14, -14) < SMOOTHED(-4, -4)) << 3) + ((SMOOTHED(4, 9) < SMOOTHED(7, -3)) << 2) + ((SMOOTHED(4, 11) < SMOOTHED(10, -4)) << 1) + ((SMOOTHED(6, 17) < SMOOTHED(9, 17)) << 0) ;
|
||||
desc[39] = ((SMOOTHED(-10, 8) < SMOOTHED(0, -11)) << 7) + ((SMOOTHED(-6, -16) < SMOOTHED(-6, 8)) << 6) + ((SMOOTHED(-13, 5) < SMOOTHED(10, -5)) << 5) + ((SMOOTHED(3, 2) < SMOOTHED(12, 16)) << 4) + ((SMOOTHED(13, -8) < SMOOTHED(0, -6)) << 3) + ((SMOOTHED(10, 0) < SMOOTHED(4, -11)) << 2) + ((SMOOTHED(8, 5) < SMOOTHED(10, -2)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(-13, 3)) << 0) ;
|
||||
desc[40] = ((SMOOTHED(2, 4) < SMOOTHED(-7, -3)) << 7) + ((SMOOTHED(-14, -2) < SMOOTHED(-11, 16)) << 6) + ((SMOOTHED(11, -6) < SMOOTHED(7, 6)) << 5) + ((SMOOTHED(-3, 15) < SMOOTHED(8, -10)) << 4) + ((SMOOTHED(-3, 8) < SMOOTHED(12, -12)) << 3) + ((SMOOTHED(-13, 6) < SMOOTHED(-14, 7)) << 2) + ((SMOOTHED(-11, -5) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(7, -6) < SMOOTHED(6, 3)) << 0) ;
|
||||
desc[41] = ((SMOOTHED(-4, 10) < SMOOTHED(5, 1)) << 7) + ((SMOOTHED(9, 16) < SMOOTHED(10, 13)) << 6) + ((SMOOTHED(-17, 10) < SMOOTHED(2, 8)) << 5) + ((SMOOTHED(-5, 1) < SMOOTHED(4, -4)) << 4) + ((SMOOTHED(-14, 8) < SMOOTHED(-5, 2)) << 3) + ((SMOOTHED(4, -9) < SMOOTHED(-6, -3)) << 2) + ((SMOOTHED(3, -7) < SMOOTHED(-10, 0)) << 1) + ((SMOOTHED(-2, -8) < SMOOTHED(-10, 4)) << 0) ;
|
||||
desc[42] = ((SMOOTHED(-8, 5) < SMOOTHED(-9, 24)) << 7) + ((SMOOTHED(2, -8) < SMOOTHED(8, -9)) << 6) + ((SMOOTHED(-4, 17) < SMOOTHED(-5, 2)) << 5) + ((SMOOTHED(14, 0) < SMOOTHED(-9, 9)) << 4) + ((SMOOTHED(11, 15) < SMOOTHED(-6, 5)) << 3) + ((SMOOTHED(-8, 1) < SMOOTHED(-3, 4)) << 2) + ((SMOOTHED(9, -21) < SMOOTHED(10, 2)) << 1) + ((SMOOTHED(2, -1) < SMOOTHED(4, 11)) << 0) ;
|
||||
desc[43] = ((SMOOTHED(24, 3) < SMOOTHED(2, -2)) << 7) + ((SMOOTHED(-8, 17) < SMOOTHED(-14, -10)) << 6) + ((SMOOTHED(6, 5) < SMOOTHED(-13, 7)) << 5) + ((SMOOTHED(11, 10) < SMOOTHED(0, -1)) << 4) + ((SMOOTHED(4, 6) < SMOOTHED(-10, 6)) << 3) + ((SMOOTHED(-12, -2) < SMOOTHED(5, 6)) << 2) + ((SMOOTHED(3, -1) < SMOOTHED(8, -15)) << 1) + ((SMOOTHED(1, -4) < SMOOTHED(-7, 11)) << 0) ;
|
||||
desc[44] = ((SMOOTHED(1, 11) < SMOOTHED(5, 0)) << 7) + ((SMOOTHED(6, -12) < SMOOTHED(10, 1)) << 6) + ((SMOOTHED(-3, -2) < SMOOTHED(-1, 4)) << 5) + ((SMOOTHED(-2, -11) < SMOOTHED(-1, 12)) << 4) + ((SMOOTHED(7, -8) < SMOOTHED(-20, -18)) << 3) + ((SMOOTHED(2, 0) < SMOOTHED(-9, 2)) << 2) + ((SMOOTHED(-13, -1) < SMOOTHED(-16, 2)) << 1) + ((SMOOTHED(3, -1) < SMOOTHED(-5, -17)) << 0) ;
|
||||
desc[45] = ((SMOOTHED(15, 8) < SMOOTHED(3, -14)) << 7) + ((SMOOTHED(-13, -12) < SMOOTHED(6, 15)) << 6) + ((SMOOTHED(2, -8) < SMOOTHED(2, 6)) << 5) + ((SMOOTHED(6, 22) < SMOOTHED(-3, -23)) << 4) + ((SMOOTHED(-2, -7) < SMOOTHED(-6, 0)) << 3) + ((SMOOTHED(13, -10) < SMOOTHED(-6, 6)) << 2) + ((SMOOTHED(6, 7) < SMOOTHED(-10, 12)) << 1) + ((SMOOTHED(-6, 7) < SMOOTHED(-2, 11)) << 0) ;
|
||||
desc[46] = ((SMOOTHED(0, -22) < SMOOTHED(-2, -17)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-11, -14)) << 6) + ((SMOOTHED(-2, -8) < SMOOTHED(7, 12)) << 5) + ((SMOOTHED(12, -5) < SMOOTHED(7, -13)) << 4) + ((SMOOTHED(2, -2) < SMOOTHED(-7, 6)) << 3) + ((SMOOTHED(0, 8) < SMOOTHED(-3, 23)) << 2) + ((SMOOTHED(6, 12) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(-21, -10) < SMOOTHED(10, 8)) << 0) ;
|
||||
desc[47] = ((SMOOTHED(-3, 0) < SMOOTHED(7, 15)) << 7) + ((SMOOTHED(7, -6) < SMOOTHED(-5, -12)) << 6) + ((SMOOTHED(-21, -10) < SMOOTHED(12, -11)) << 5) + ((SMOOTHED(-5, -11) < SMOOTHED(8, -11)) << 4) + ((SMOOTHED(5, 0) < SMOOTHED(-11, -1)) << 3) + ((SMOOTHED(8, -9) < SMOOTHED(7, -1)) << 2) + ((SMOOTHED(11, -23) < SMOOTHED(21, -5)) << 1) + ((SMOOTHED(0, -5) < SMOOTHED(-8, 6)) << 0) ;
|
||||
desc[48] = ((SMOOTHED(-6, 8) < SMOOTHED(8, 12)) << 7) + ((SMOOTHED(-7, 5) < SMOOTHED(3, -2)) << 6) + ((SMOOTHED(-5, -20) < SMOOTHED(-12, 9)) << 5) + ((SMOOTHED(-6, 12) < SMOOTHED(-11, 3)) << 4) + ((SMOOTHED(4, 5) < SMOOTHED(13, 11)) << 3) + ((SMOOTHED(2, 12) < SMOOTHED(13, -12)) << 2) + ((SMOOTHED(-4, -13) < SMOOTHED(4, 7)) << 1) + ((SMOOTHED(0, 15) < SMOOTHED(-3, -16)) << 0) ;
|
||||
desc[49] = ((SMOOTHED(-3, 2) < SMOOTHED(-2, 14)) << 7) + ((SMOOTHED(4, -14) < SMOOTHED(16, -11)) << 6) + ((SMOOTHED(-13, 3) < SMOOTHED(23, 10)) << 5) + ((SMOOTHED(9, -19) < SMOOTHED(2, 5)) << 4) + ((SMOOTHED(5, 3) < SMOOTHED(14, -7)) << 3) + ((SMOOTHED(19, -13) < SMOOTHED(-11, 15)) << 2) + ((SMOOTHED(14, 0) < SMOOTHED(-2, -5)) << 1) + ((SMOOTHED(11, -4) < SMOOTHED(0, -6)) << 0) ;
|
||||
desc[50] = ((SMOOTHED(-2, 5) < SMOOTHED(-13, -8)) << 7) + ((SMOOTHED(-11, -15) < SMOOTHED(-7, -17)) << 6) + ((SMOOTHED(1, 3) < SMOOTHED(-10, -8)) << 5) + ((SMOOTHED(-13, -10) < SMOOTHED(7, -12)) << 4) + ((SMOOTHED(0, -13) < SMOOTHED(23, -6)) << 3) + ((SMOOTHED(2, -17) < SMOOTHED(-7, -3)) << 2) + ((SMOOTHED(1, 3) < SMOOTHED(4, -10)) << 1) + ((SMOOTHED(13, 4) < SMOOTHED(14, -6)) << 0) ;
|
||||
desc[51] = ((SMOOTHED(-19, -2) < SMOOTHED(-1, 5)) << 7) + ((SMOOTHED(9, -8) < SMOOTHED(10, -5)) << 6) + ((SMOOTHED(7, -1) < SMOOTHED(5, 7)) << 5) + ((SMOOTHED(9, -10) < SMOOTHED(19, 0)) << 4) + ((SMOOTHED(7, 5) < SMOOTHED(-4, -7)) << 3) + ((SMOOTHED(-11, 1) < SMOOTHED(-1, -11)) << 2) + ((SMOOTHED(2, -1) < SMOOTHED(-4, 11)) << 1) + ((SMOOTHED(-1, 7) < SMOOTHED(2, -2)) << 0) ;
|
||||
desc[52] = ((SMOOTHED(1, -20) < SMOOTHED(-9, -6)) << 7) + ((SMOOTHED(-4, -18) < SMOOTHED(8, -18)) << 6) + ((SMOOTHED(-16, -2) < SMOOTHED(7, -6)) << 5) + ((SMOOTHED(-3, -6) < SMOOTHED(-1, -4)) << 4) + ((SMOOTHED(0, -16) < SMOOTHED(24, -5)) << 3) + ((SMOOTHED(-4, -2) < SMOOTHED(-1, 9)) << 2) + ((SMOOTHED(-8, 2) < SMOOTHED(-6, 15)) << 1) + ((SMOOTHED(11, 4) < SMOOTHED(0, -3)) << 0) ;
|
||||
desc[53] = ((SMOOTHED(7, 6) < SMOOTHED(2, -10)) << 7) + ((SMOOTHED(-7, -9) < SMOOTHED(12, -6)) << 6) + ((SMOOTHED(24, 15) < SMOOTHED(-8, -1)) << 5) + ((SMOOTHED(15, -9) < SMOOTHED(-3, -15)) << 4) + ((SMOOTHED(17, -5) < SMOOTHED(11, -10)) << 3) + ((SMOOTHED(-2, 13) < SMOOTHED(-15, 4)) << 2) + ((SMOOTHED(-2, -1) < SMOOTHED(4, -23)) << 1) + ((SMOOTHED(-16, 3) < SMOOTHED(-7, -14)) << 0) ;
|
||||
desc[54] = ((SMOOTHED(-3, -5) < SMOOTHED(-10, -9)) << 7) + ((SMOOTHED(-5, 3) < SMOOTHED(-2, -1)) << 6) + ((SMOOTHED(-1, 4) < SMOOTHED(1, 8)) << 5) + ((SMOOTHED(12, 9) < SMOOTHED(9, -14)) << 4) + ((SMOOTHED(-9, 17) < SMOOTHED(-3, 0)) << 3) + ((SMOOTHED(5, 4) < SMOOTHED(13, -6)) << 2) + ((SMOOTHED(-1, -8) < SMOOTHED(19, 10)) << 1) + ((SMOOTHED(8, -5) < SMOOTHED(-15, 2)) << 0) ;
|
||||
desc[55] = ((SMOOTHED(-12, -9) < SMOOTHED(-4, -5)) << 7) + ((SMOOTHED(12, 0) < SMOOTHED(24, 4)) << 6) + ((SMOOTHED(8, -2) < SMOOTHED(14, 4)) << 5) + ((SMOOTHED(8, -4) < SMOOTHED(-7, 16)) << 4) + ((SMOOTHED(5, -1) < SMOOTHED(-8, -4)) << 3) + ((SMOOTHED(-2, 18) < SMOOTHED(-5, 17)) << 2) + ((SMOOTHED(8, -2) < SMOOTHED(-9, -2)) << 1) + ((SMOOTHED(3, -7) < SMOOTHED(1, -6)) << 0) ;
|
||||
desc[56] = ((SMOOTHED(-5, -22) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, -10) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(-3, -13) < SMOOTHED(3, 9)) << 5) + ((SMOOTHED(-4, -1) < SMOOTHED(-1, 0)) << 4) + ((SMOOTHED(-7, -21) < SMOOTHED(12, -19)) << 3) + ((SMOOTHED(-8, 8) < SMOOTHED(24, 8)) << 2) + ((SMOOTHED(12, -6) < SMOOTHED(-2, 3)) << 1) + ((SMOOTHED(-5, -11) < SMOOTHED(-22, -4)) << 0) ;
|
||||
desc[57] = ((SMOOTHED(-3, 5) < SMOOTHED(-4, 4)) << 7) + ((SMOOTHED(-16, 24) < SMOOTHED(7, -9)) << 6) + ((SMOOTHED(-10, 23) < SMOOTHED(-9, 18)) << 5) + ((SMOOTHED(1, 12) < SMOOTHED(17, 21)) << 4) + ((SMOOTHED(24, -6) < SMOOTHED(-3, -11)) << 3) + ((SMOOTHED(-7, 17) < SMOOTHED(1, -6)) << 2) + ((SMOOTHED(4, 4) < SMOOTHED(2, -7)) << 1) + ((SMOOTHED(14, 6) < SMOOTHED(-12, 3)) << 0) ;
|
||||
desc[58] = ((SMOOTHED(-6, 0) < SMOOTHED(-16, 13)) << 7) + ((SMOOTHED(-10, 5) < SMOOTHED(7, 12)) << 6) + ((SMOOTHED(5, 2) < SMOOTHED(6, -3)) << 5) + ((SMOOTHED(7, 0) < SMOOTHED(-23, 1)) << 4) + ((SMOOTHED(15, -5) < SMOOTHED(1, 14)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(6, 6)) << 2) + ((SMOOTHED(6, -9) < SMOOTHED(-9, 12)) << 1) + ((SMOOTHED(4, -2) < SMOOTHED(-4, 7)) << 0) ;
|
||||
desc[59] = ((SMOOTHED(-4, -5) < SMOOTHED(4, 4)) << 7) + ((SMOOTHED(-13, 0) < SMOOTHED(6, -10)) << 6) + ((SMOOTHED(2, -12) < SMOOTHED(-6, -3)) << 5) + ((SMOOTHED(16, 0) < SMOOTHED(-3, 3)) << 4) + ((SMOOTHED(5, -14) < SMOOTHED(6, 11)) << 3) + ((SMOOTHED(5, 11) < SMOOTHED(0, -13)) << 2) + ((SMOOTHED(7, 5) < SMOOTHED(-1, -5)) << 1) + ((SMOOTHED(12, 4) < SMOOTHED(6, 10)) << 0) ;
|
||||
desc[60] = ((SMOOTHED(-10, 4) < SMOOTHED(-1, -11)) << 7) + ((SMOOTHED(4, 10) < SMOOTHED(-14, 5)) << 6) + ((SMOOTHED(11, -14) < SMOOTHED(-13, 0)) << 5) + ((SMOOTHED(2, 8) < SMOOTHED(12, 24)) << 4) + ((SMOOTHED(-1, 3) < SMOOTHED(-1, 2)) << 3) + ((SMOOTHED(9, -14) < SMOOTHED(-23, 3)) << 2) + ((SMOOTHED(-8, -6) < SMOOTHED(0, 9)) << 1) + ((SMOOTHED(-15, 14) < SMOOTHED(10, -10)) << 0) ;
|
||||
desc[61] = ((SMOOTHED(-10, -6) < SMOOTHED(-7, -5)) << 7) + ((SMOOTHED(11, 5) < SMOOTHED(-3, -15)) << 6) + ((SMOOTHED(1, 0) < SMOOTHED(1, 8)) << 5) + ((SMOOTHED(-11, -6) < SMOOTHED(-4, -18)) << 4) + ((SMOOTHED(9, 0) < SMOOTHED(22, -4)) << 3) + ((SMOOTHED(-5, -1) < SMOOTHED(-9, 4)) << 2) + ((SMOOTHED(-20, 2) < SMOOTHED(1, 6)) << 1) + ((SMOOTHED(1, 2) < SMOOTHED(-9, -12)) << 0) ;
|
||||
desc[62] = ((SMOOTHED(5, 15) < SMOOTHED(4, -6)) << 7) + ((SMOOTHED(19, 4) < SMOOTHED(4, 11)) << 6) + ((SMOOTHED(17, -4) < SMOOTHED(-8, -1)) << 5) + ((SMOOTHED(-8, -12) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(11, 9) < SMOOTHED(8, 1)) << 3) + ((SMOOTHED(9, 22) < SMOOTHED(-15, 15)) << 2) + ((SMOOTHED(-7, -7) < SMOOTHED(1, -23)) << 1) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 2)) << 0) ;
|
||||
desc[63] = ((SMOOTHED(3, -5) < SMOOTHED(11, -11)) << 7) + ((SMOOTHED(3, -18) < SMOOTHED(14, -5)) << 6) + ((SMOOTHED(-20, 7) < SMOOTHED(-10, -23)) << 5) + ((SMOOTHED(-2, -5) < SMOOTHED(6, 0)) << 4) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 3) + ((SMOOTHED(-6, -1) < SMOOTHED(14, -2)) << 2) + ((SMOOTHED(-12, -16) < SMOOTHED(15, 6)) << 1) + ((SMOOTHED(-12, -2) < SMOOTHED(3, -19)) << 0) ;
|
||||
desc[0] = (uchar)(((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));
|
||||
desc[1] = (uchar)(((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0));
|
||||
desc[2] = (uchar)(((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0));
|
||||
desc[3] = (uchar)(((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0));
|
||||
desc[4] = (uchar)(((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0));
|
||||
desc[5] = (uchar)(((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0));
|
||||
desc[6] = (uchar)(((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0));
|
||||
desc[7] = (uchar)(((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0));
|
||||
desc[8] = (uchar)(((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0));
|
||||
desc[9] = (uchar)(((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0));
|
||||
desc[10] = (uchar)(((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0));
|
||||
desc[11] = (uchar)(((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0));
|
||||
desc[12] = (uchar)(((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0));
|
||||
desc[13] = (uchar)(((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0));
|
||||
desc[14] = (uchar)(((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0));
|
||||
desc[15] = (uchar)(((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0));
|
||||
desc[16] = (uchar)(((SMOOTHED(-9, 1) < SMOOTHED(-18, 0)) << 7) + ((SMOOTHED(4, 0) < SMOOTHED(1, 12)) << 6) + ((SMOOTHED(0, 9) < SMOOTHED(-14, -10)) << 5) + ((SMOOTHED(-13, -9) < SMOOTHED(-2, 6)) << 4) + ((SMOOTHED(1, 5) < SMOOTHED(10, 10)) << 3) + ((SMOOTHED(-3, -6) < SMOOTHED(-16, -5)) << 2) + ((SMOOTHED(11, 6) < SMOOTHED(-5, 0)) << 1) + ((SMOOTHED(-23, 10) < SMOOTHED(1, 2)) << 0));
|
||||
desc[17] = (uchar)(((SMOOTHED(13, -5) < SMOOTHED(-3, 9)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-13, -5)) << 6) + ((SMOOTHED(10, 13) < SMOOTHED(-11, 8)) << 5) + ((SMOOTHED(19, 20) < SMOOTHED(-9, 2)) << 4) + ((SMOOTHED(4, -8) < SMOOTHED(0, -9)) << 3) + ((SMOOTHED(-14, 10) < SMOOTHED(15, 19)) << 2) + ((SMOOTHED(-14, -12) < SMOOTHED(-10, -3)) << 1) + ((SMOOTHED(-23, -3) < SMOOTHED(17, -2)) << 0));
|
||||
desc[18] = (uchar)(((SMOOTHED(-3, -11) < SMOOTHED(6, -14)) << 7) + ((SMOOTHED(19, -2) < SMOOTHED(-4, 2)) << 6) + ((SMOOTHED(-5, 5) < SMOOTHED(3, -13)) << 5) + ((SMOOTHED(2, -2) < SMOOTHED(-5, 4)) << 4) + ((SMOOTHED(17, 4) < SMOOTHED(17, -11)) << 3) + ((SMOOTHED(-7, -2) < SMOOTHED(1, 23)) << 2) + ((SMOOTHED(8, 13) < SMOOTHED(1, -16)) << 1) + ((SMOOTHED(-13, -5) < SMOOTHED(1, -17)) << 0));
|
||||
desc[19] = (uchar)(((SMOOTHED(4, 6) < SMOOTHED(-8, -3)) << 7) + ((SMOOTHED(-5, -9) < SMOOTHED(-2, -10)) << 6) + ((SMOOTHED(-9, 0) < SMOOTHED(-7, -2)) << 5) + ((SMOOTHED(5, 0) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-4, -16) < SMOOTHED(6, 3)) << 3) + ((SMOOTHED(2, -15) < SMOOTHED(-2, 12)) << 2) + ((SMOOTHED(4, -1) < SMOOTHED(6, 2)) << 1) + ((SMOOTHED(1, 1) < SMOOTHED(-2, -8)) << 0));
|
||||
desc[20] = (uchar)(((SMOOTHED(-2, 12) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, 8) < SMOOTHED(-9, 9)) << 6) + ((SMOOTHED(2, -10) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-4, 10) < SMOOTHED(-9, 4)) << 4) + ((SMOOTHED(6, 12) < SMOOTHED(2, 5)) << 3) + ((SMOOTHED(-3, -8) < SMOOTHED(0, 5)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-7, 2)) << 1) + ((SMOOTHED(-1, -10) < SMOOTHED(7, -18)) << 0));
|
||||
desc[21] = (uchar)(((SMOOTHED(-1, 8) < SMOOTHED(-9, -10)) << 7) + ((SMOOTHED(-23, -1) < SMOOTHED(6, 2)) << 6) + ((SMOOTHED(-5, -3) < SMOOTHED(3, 2)) << 5) + ((SMOOTHED(0, 11) < SMOOTHED(-4, -7)) << 4) + ((SMOOTHED(15, 2) < SMOOTHED(-10, -3)) << 3) + ((SMOOTHED(-20, -8) < SMOOTHED(-13, 3)) << 2) + ((SMOOTHED(-19, -12) < SMOOTHED(5, -11)) << 1) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 0));
|
||||
desc[22] = (uchar)(((SMOOTHED(7, 4) < SMOOTHED(-12, 0)) << 7) + ((SMOOTHED(5, -1) < SMOOTHED(-14, -6)) << 6) + ((SMOOTHED(-4, 11) < SMOOTHED(0, -4)) << 5) + ((SMOOTHED(3, 10) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(13, 21) < SMOOTHED(-11, 6)) << 3) + ((SMOOTHED(-12, 24) < SMOOTHED(-7, -4)) << 2) + ((SMOOTHED(4, 16) < SMOOTHED(3, -14)) << 1) + ((SMOOTHED(-3, 5) < SMOOTHED(-7, -12)) << 0));
|
||||
desc[23] = (uchar)(((SMOOTHED(0, -4) < SMOOTHED(7, -5)) << 7) + ((SMOOTHED(-17, -9) < SMOOTHED(13, -7)) << 6) + ((SMOOTHED(22, -6) < SMOOTHED(-11, 5)) << 5) + ((SMOOTHED(2, -8) < SMOOTHED(23, -11)) << 4) + ((SMOOTHED(7, -10) < SMOOTHED(-1, 14)) << 3) + ((SMOOTHED(-3, -10) < SMOOTHED(8, 3)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-6, 0)) << 1) + ((SMOOTHED(-7, -21) < SMOOTHED(6, -14)) << 0));
|
||||
desc[24] = (uchar)(((SMOOTHED(18, 19) < SMOOTHED(-4, -6)) << 7) + ((SMOOTHED(10, 7) < SMOOTHED(-1, -4)) << 6) + ((SMOOTHED(-1, 21) < SMOOTHED(1, -5)) << 5) + ((SMOOTHED(-10, 6) < SMOOTHED(-11, -2)) << 4) + ((SMOOTHED(18, -3) < SMOOTHED(-1, 7)) << 3) + ((SMOOTHED(-3, -9) < SMOOTHED(-5, 10)) << 2) + ((SMOOTHED(-13, 14) < SMOOTHED(17, -3)) << 1) + ((SMOOTHED(11, -19) < SMOOTHED(-1, -18)) << 0));
|
||||
desc[25] = (uchar)(((SMOOTHED(8, -2) < SMOOTHED(-18, -23)) << 7) + ((SMOOTHED(0, -5) < SMOOTHED(-2, -9)) << 6) + ((SMOOTHED(-4, -11) < SMOOTHED(2, -8)) << 5) + ((SMOOTHED(14, 6) < SMOOTHED(-3, -6)) << 4) + ((SMOOTHED(-3, 0) < SMOOTHED(-15, 0)) << 3) + ((SMOOTHED(-9, 4) < SMOOTHED(-15, -9)) << 2) + ((SMOOTHED(-1, 11) < SMOOTHED(3, 11)) << 1) + ((SMOOTHED(-10, -16) < SMOOTHED(-7, 7)) << 0));
|
||||
desc[26] = (uchar)(((SMOOTHED(-2, -10) < SMOOTHED(-10, -2)) << 7) + ((SMOOTHED(-5, -3) < SMOOTHED(5, -23)) << 6) + ((SMOOTHED(13, -8) < SMOOTHED(-15, -11)) << 5) + ((SMOOTHED(-15, 11) < SMOOTHED(6, -6)) << 4) + ((SMOOTHED(-16, -3) < SMOOTHED(-2, 2)) << 3) + ((SMOOTHED(6, 12) < SMOOTHED(-16, 24)) << 2) + ((SMOOTHED(-10, 0) < SMOOTHED(8, 11)) << 1) + ((SMOOTHED(-7, 7) < SMOOTHED(-19, -7)) << 0));
|
||||
desc[27] = (uchar)(((SMOOTHED(5, 16) < SMOOTHED(9, -3)) << 7) + ((SMOOTHED(9, 7) < SMOOTHED(-7, -16)) << 6) + ((SMOOTHED(3, 2) < SMOOTHED(-10, 9)) << 5) + ((SMOOTHED(21, 1) < SMOOTHED(8, 7)) << 4) + ((SMOOTHED(7, 0) < SMOOTHED(1, 17)) << 3) + ((SMOOTHED(-8, 12) < SMOOTHED(9, 6)) << 2) + ((SMOOTHED(11, -7) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(19, 0) < SMOOTHED(9, 3)) << 0));
|
||||
desc[28] = (uchar)(((SMOOTHED(1, -7) < SMOOTHED(-5, -11)) << 7) + ((SMOOTHED(0, 8) < SMOOTHED(-2, 14)) << 6) + ((SMOOTHED(12, -2) < SMOOTHED(-15, -6)) << 5) + ((SMOOTHED(4, 12) < SMOOTHED(0, -21)) << 4) + ((SMOOTHED(17, -4) < SMOOTHED(-6, -7)) << 3) + ((SMOOTHED(-10, -9) < SMOOTHED(-14, -7)) << 2) + ((SMOOTHED(-15, -10) < SMOOTHED(-15, -14)) << 1) + ((SMOOTHED(-7, -5) < SMOOTHED(5, -12)) << 0));
|
||||
desc[29] = (uchar)(((SMOOTHED(-4, 0) < SMOOTHED(15, -4)) << 7) + ((SMOOTHED(5, 2) < SMOOTHED(-6, -23)) << 6) + ((SMOOTHED(-4, -21) < SMOOTHED(-6, 4)) << 5) + ((SMOOTHED(-10, 5) < SMOOTHED(-15, 6)) << 4) + ((SMOOTHED(4, -3) < SMOOTHED(-1, 5)) << 3) + ((SMOOTHED(-4, 19) < SMOOTHED(-23, -4)) << 2) + ((SMOOTHED(-4, 17) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(1, 12) < SMOOTHED(4, -14)) << 0));
|
||||
desc[30] = (uchar)(((SMOOTHED(-11, -6) < SMOOTHED(-20, 10)) << 7) + ((SMOOTHED(4, 5) < SMOOTHED(3, 20)) << 6) + ((SMOOTHED(-8, -20) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-19, 9) < SMOOTHED(9, -3)) << 4) + ((SMOOTHED(18, 15) < SMOOTHED(11, -4)) << 3) + ((SMOOTHED(12, 16) < SMOOTHED(8, 7)) << 2) + ((SMOOTHED(-14, -8) < SMOOTHED(-3, 9)) << 1) + ((SMOOTHED(-6, 0) < SMOOTHED(2, -4)) << 0));
|
||||
desc[31] = (uchar)(((SMOOTHED(1, -10) < SMOOTHED(-1, 2)) << 7) + ((SMOOTHED(8, -7) < SMOOTHED(-6, 18)) << 6) + ((SMOOTHED(9, 12) < SMOOTHED(-7, -23)) << 5) + ((SMOOTHED(8, -6) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-9, 6) < SMOOTHED(-12, -7)) << 3) + ((SMOOTHED(-1, -2) < SMOOTHED(-7, 2)) << 2) + ((SMOOTHED(9, 9) < SMOOTHED(7, 15)) << 1) + ((SMOOTHED(6, 2) < SMOOTHED(-6, 6)) << 0));
|
||||
desc[32] = (uchar)(((SMOOTHED(16, 12) < SMOOTHED(0, 19)) << 7) + ((SMOOTHED(4, 3) < SMOOTHED(6, 0)) << 6) + ((SMOOTHED(-2, -1) < SMOOTHED(2, 17)) << 5) + ((SMOOTHED(8, 1) < SMOOTHED(3, 1)) << 4) + ((SMOOTHED(-12, -1) < SMOOTHED(-11, 0)) << 3) + ((SMOOTHED(-11, 2) < SMOOTHED(7, 9)) << 2) + ((SMOOTHED(-1, 3) < SMOOTHED(-19, 4)) << 1) + ((SMOOTHED(-1, -11) < SMOOTHED(-1, 3)) << 0));
|
||||
desc[33] = (uchar)(((SMOOTHED(1, -10) < SMOOTHED(-10, -4)) << 7) + ((SMOOTHED(-2, 3) < SMOOTHED(6, 11)) << 6) + ((SMOOTHED(3, 7) < SMOOTHED(-9, -8)) << 5) + ((SMOOTHED(24, -14) < SMOOTHED(-2, -10)) << 4) + ((SMOOTHED(-3, -3) < SMOOTHED(-18, -6)) << 3) + ((SMOOTHED(-13, -10) < SMOOTHED(-7, -1)) << 2) + ((SMOOTHED(2, -7) < SMOOTHED(9, -6)) << 1) + ((SMOOTHED(2, -4) < SMOOTHED(6, -13)) << 0));
|
||||
desc[34] = (uchar)(((SMOOTHED(4, -4) < SMOOTHED(-2, 3)) << 7) + ((SMOOTHED(-4, 2) < SMOOTHED(9, 13)) << 6) + ((SMOOTHED(-11, 5) < SMOOTHED(-6, -11)) << 5) + ((SMOOTHED(4, -2) < SMOOTHED(11, -9)) << 4) + ((SMOOTHED(-19, 0) < SMOOTHED(-23, -5)) << 3) + ((SMOOTHED(-5, -7) < SMOOTHED(-3, -6)) << 2) + ((SMOOTHED(-6, -4) < SMOOTHED(12, 14)) << 1) + ((SMOOTHED(12, -11) < SMOOTHED(-8, -16)) << 0));
|
||||
desc[35] = (uchar)(((SMOOTHED(-21, 15) < SMOOTHED(-12, 6)) << 7) + ((SMOOTHED(-2, -1) < SMOOTHED(-8, 16)) << 6) + ((SMOOTHED(6, -1) < SMOOTHED(-8, -2)) << 5) + ((SMOOTHED(1, -1) < SMOOTHED(-9, 8)) << 4) + ((SMOOTHED(3, -4) < SMOOTHED(-2, -2)) << 3) + ((SMOOTHED(-7, 0) < SMOOTHED(4, -8)) << 2) + ((SMOOTHED(11, -11) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(2, 3) < SMOOTHED(11, 7)) << 0));
|
||||
desc[36] = (uchar)(((SMOOTHED(-7, -4) < SMOOTHED(-9, -6)) << 7) + ((SMOOTHED(3, -7) < SMOOTHED(-5, 0)) << 6) + ((SMOOTHED(3, -7) < SMOOTHED(-10, -5)) << 5) + ((SMOOTHED(-3, -1) < SMOOTHED(8, -10)) << 4) + ((SMOOTHED(0, 8) < SMOOTHED(5, 1)) << 3) + ((SMOOTHED(9, 0) < SMOOTHED(1, 16)) << 2) + ((SMOOTHED(8, 4) < SMOOTHED(-11, -3)) << 1) + ((SMOOTHED(-15, 9) < SMOOTHED(8, 17)) << 0));
|
||||
desc[37] = (uchar)(((SMOOTHED(0, 2) < SMOOTHED(-9, 17)) << 7) + ((SMOOTHED(-6, -11) < SMOOTHED(-10, -3)) << 6) + ((SMOOTHED(1, 1) < SMOOTHED(15, -8)) << 5) + ((SMOOTHED(-12, -13) < SMOOTHED(-2, 4)) << 4) + ((SMOOTHED(-6, 4) < SMOOTHED(-6, -10)) << 3) + ((SMOOTHED(5, -7) < SMOOTHED(7, -5)) << 2) + ((SMOOTHED(10, 6) < SMOOTHED(8, 9)) << 1) + ((SMOOTHED(-5, 7) < SMOOTHED(-18, -3)) << 0));
|
||||
desc[38] = (uchar)(((SMOOTHED(-6, 3) < SMOOTHED(5, 4)) << 7) + ((SMOOTHED(-10, -13) < SMOOTHED(-5, -3)) << 6) + ((SMOOTHED(-11, 2) < SMOOTHED(-16, 0)) << 5) + ((SMOOTHED(7, -21) < SMOOTHED(-5, -13)) << 4) + ((SMOOTHED(-14, -14) < SMOOTHED(-4, -4)) << 3) + ((SMOOTHED(4, 9) < SMOOTHED(7, -3)) << 2) + ((SMOOTHED(4, 11) < SMOOTHED(10, -4)) << 1) + ((SMOOTHED(6, 17) < SMOOTHED(9, 17)) << 0));
|
||||
desc[39] = (uchar)(((SMOOTHED(-10, 8) < SMOOTHED(0, -11)) << 7) + ((SMOOTHED(-6, -16) < SMOOTHED(-6, 8)) << 6) + ((SMOOTHED(-13, 5) < SMOOTHED(10, -5)) << 5) + ((SMOOTHED(3, 2) < SMOOTHED(12, 16)) << 4) + ((SMOOTHED(13, -8) < SMOOTHED(0, -6)) << 3) + ((SMOOTHED(10, 0) < SMOOTHED(4, -11)) << 2) + ((SMOOTHED(8, 5) < SMOOTHED(10, -2)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(-13, 3)) << 0));
|
||||
desc[40] = (uchar)(((SMOOTHED(2, 4) < SMOOTHED(-7, -3)) << 7) + ((SMOOTHED(-14, -2) < SMOOTHED(-11, 16)) << 6) + ((SMOOTHED(11, -6) < SMOOTHED(7, 6)) << 5) + ((SMOOTHED(-3, 15) < SMOOTHED(8, -10)) << 4) + ((SMOOTHED(-3, 8) < SMOOTHED(12, -12)) << 3) + ((SMOOTHED(-13, 6) < SMOOTHED(-14, 7)) << 2) + ((SMOOTHED(-11, -5) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(7, -6) < SMOOTHED(6, 3)) << 0));
|
||||
desc[41] = (uchar)(((SMOOTHED(-4, 10) < SMOOTHED(5, 1)) << 7) + ((SMOOTHED(9, 16) < SMOOTHED(10, 13)) << 6) + ((SMOOTHED(-17, 10) < SMOOTHED(2, 8)) << 5) + ((SMOOTHED(-5, 1) < SMOOTHED(4, -4)) << 4) + ((SMOOTHED(-14, 8) < SMOOTHED(-5, 2)) << 3) + ((SMOOTHED(4, -9) < SMOOTHED(-6, -3)) << 2) + ((SMOOTHED(3, -7) < SMOOTHED(-10, 0)) << 1) + ((SMOOTHED(-2, -8) < SMOOTHED(-10, 4)) << 0));
|
||||
desc[42] = (uchar)(((SMOOTHED(-8, 5) < SMOOTHED(-9, 24)) << 7) + ((SMOOTHED(2, -8) < SMOOTHED(8, -9)) << 6) + ((SMOOTHED(-4, 17) < SMOOTHED(-5, 2)) << 5) + ((SMOOTHED(14, 0) < SMOOTHED(-9, 9)) << 4) + ((SMOOTHED(11, 15) < SMOOTHED(-6, 5)) << 3) + ((SMOOTHED(-8, 1) < SMOOTHED(-3, 4)) << 2) + ((SMOOTHED(9, -21) < SMOOTHED(10, 2)) << 1) + ((SMOOTHED(2, -1) < SMOOTHED(4, 11)) << 0));
|
||||
desc[43] = (uchar)(((SMOOTHED(24, 3) < SMOOTHED(2, -2)) << 7) + ((SMOOTHED(-8, 17) < SMOOTHED(-14, -10)) << 6) + ((SMOOTHED(6, 5) < SMOOTHED(-13, 7)) << 5) + ((SMOOTHED(11, 10) < SMOOTHED(0, -1)) << 4) + ((SMOOTHED(4, 6) < SMOOTHED(-10, 6)) << 3) + ((SMOOTHED(-12, -2) < SMOOTHED(5, 6)) << 2) + ((SMOOTHED(3, -1) < SMOOTHED(8, -15)) << 1) + ((SMOOTHED(1, -4) < SMOOTHED(-7, 11)) << 0));
|
||||
desc[44] = (uchar)(((SMOOTHED(1, 11) < SMOOTHED(5, 0)) << 7) + ((SMOOTHED(6, -12) < SMOOTHED(10, 1)) << 6) + ((SMOOTHED(-3, -2) < SMOOTHED(-1, 4)) << 5) + ((SMOOTHED(-2, -11) < SMOOTHED(-1, 12)) << 4) + ((SMOOTHED(7, -8) < SMOOTHED(-20, -18)) << 3) + ((SMOOTHED(2, 0) < SMOOTHED(-9, 2)) << 2) + ((SMOOTHED(-13, -1) < SMOOTHED(-16, 2)) << 1) + ((SMOOTHED(3, -1) < SMOOTHED(-5, -17)) << 0));
|
||||
desc[45] = (uchar)(((SMOOTHED(15, 8) < SMOOTHED(3, -14)) << 7) + ((SMOOTHED(-13, -12) < SMOOTHED(6, 15)) << 6) + ((SMOOTHED(2, -8) < SMOOTHED(2, 6)) << 5) + ((SMOOTHED(6, 22) < SMOOTHED(-3, -23)) << 4) + ((SMOOTHED(-2, -7) < SMOOTHED(-6, 0)) << 3) + ((SMOOTHED(13, -10) < SMOOTHED(-6, 6)) << 2) + ((SMOOTHED(6, 7) < SMOOTHED(-10, 12)) << 1) + ((SMOOTHED(-6, 7) < SMOOTHED(-2, 11)) << 0));
|
||||
desc[46] = (uchar)(((SMOOTHED(0, -22) < SMOOTHED(-2, -17)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-11, -14)) << 6) + ((SMOOTHED(-2, -8) < SMOOTHED(7, 12)) << 5) + ((SMOOTHED(12, -5) < SMOOTHED(7, -13)) << 4) + ((SMOOTHED(2, -2) < SMOOTHED(-7, 6)) << 3) + ((SMOOTHED(0, 8) < SMOOTHED(-3, 23)) << 2) + ((SMOOTHED(6, 12) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(-21, -10) < SMOOTHED(10, 8)) << 0));
|
||||
desc[47] = (uchar)(((SMOOTHED(-3, 0) < SMOOTHED(7, 15)) << 7) + ((SMOOTHED(7, -6) < SMOOTHED(-5, -12)) << 6) + ((SMOOTHED(-21, -10) < SMOOTHED(12, -11)) << 5) + ((SMOOTHED(-5, -11) < SMOOTHED(8, -11)) << 4) + ((SMOOTHED(5, 0) < SMOOTHED(-11, -1)) << 3) + ((SMOOTHED(8, -9) < SMOOTHED(7, -1)) << 2) + ((SMOOTHED(11, -23) < SMOOTHED(21, -5)) << 1) + ((SMOOTHED(0, -5) < SMOOTHED(-8, 6)) << 0));
|
||||
desc[48] = (uchar)(((SMOOTHED(-6, 8) < SMOOTHED(8, 12)) << 7) + ((SMOOTHED(-7, 5) < SMOOTHED(3, -2)) << 6) + ((SMOOTHED(-5, -20) < SMOOTHED(-12, 9)) << 5) + ((SMOOTHED(-6, 12) < SMOOTHED(-11, 3)) << 4) + ((SMOOTHED(4, 5) < SMOOTHED(13, 11)) << 3) + ((SMOOTHED(2, 12) < SMOOTHED(13, -12)) << 2) + ((SMOOTHED(-4, -13) < SMOOTHED(4, 7)) << 1) + ((SMOOTHED(0, 15) < SMOOTHED(-3, -16)) << 0));
|
||||
desc[49] = (uchar)(((SMOOTHED(-3, 2) < SMOOTHED(-2, 14)) << 7) + ((SMOOTHED(4, -14) < SMOOTHED(16, -11)) << 6) + ((SMOOTHED(-13, 3) < SMOOTHED(23, 10)) << 5) + ((SMOOTHED(9, -19) < SMOOTHED(2, 5)) << 4) + ((SMOOTHED(5, 3) < SMOOTHED(14, -7)) << 3) + ((SMOOTHED(19, -13) < SMOOTHED(-11, 15)) << 2) + ((SMOOTHED(14, 0) < SMOOTHED(-2, -5)) << 1) + ((SMOOTHED(11, -4) < SMOOTHED(0, -6)) << 0));
|
||||
desc[50] = (uchar)(((SMOOTHED(-2, 5) < SMOOTHED(-13, -8)) << 7) + ((SMOOTHED(-11, -15) < SMOOTHED(-7, -17)) << 6) + ((SMOOTHED(1, 3) < SMOOTHED(-10, -8)) << 5) + ((SMOOTHED(-13, -10) < SMOOTHED(7, -12)) << 4) + ((SMOOTHED(0, -13) < SMOOTHED(23, -6)) << 3) + ((SMOOTHED(2, -17) < SMOOTHED(-7, -3)) << 2) + ((SMOOTHED(1, 3) < SMOOTHED(4, -10)) << 1) + ((SMOOTHED(13, 4) < SMOOTHED(14, -6)) << 0));
|
||||
desc[51] = (uchar)(((SMOOTHED(-19, -2) < SMOOTHED(-1, 5)) << 7) + ((SMOOTHED(9, -8) < SMOOTHED(10, -5)) << 6) + ((SMOOTHED(7, -1) < SMOOTHED(5, 7)) << 5) + ((SMOOTHED(9, -10) < SMOOTHED(19, 0)) << 4) + ((SMOOTHED(7, 5) < SMOOTHED(-4, -7)) << 3) + ((SMOOTHED(-11, 1) < SMOOTHED(-1, -11)) << 2) + ((SMOOTHED(2, -1) < SMOOTHED(-4, 11)) << 1) + ((SMOOTHED(-1, 7) < SMOOTHED(2, -2)) << 0));
|
||||
desc[52] = (uchar)(((SMOOTHED(1, -20) < SMOOTHED(-9, -6)) << 7) + ((SMOOTHED(-4, -18) < SMOOTHED(8, -18)) << 6) + ((SMOOTHED(-16, -2) < SMOOTHED(7, -6)) << 5) + ((SMOOTHED(-3, -6) < SMOOTHED(-1, -4)) << 4) + ((SMOOTHED(0, -16) < SMOOTHED(24, -5)) << 3) + ((SMOOTHED(-4, -2) < SMOOTHED(-1, 9)) << 2) + ((SMOOTHED(-8, 2) < SMOOTHED(-6, 15)) << 1) + ((SMOOTHED(11, 4) < SMOOTHED(0, -3)) << 0));
|
||||
desc[53] = (uchar)(((SMOOTHED(7, 6) < SMOOTHED(2, -10)) << 7) + ((SMOOTHED(-7, -9) < SMOOTHED(12, -6)) << 6) + ((SMOOTHED(24, 15) < SMOOTHED(-8, -1)) << 5) + ((SMOOTHED(15, -9) < SMOOTHED(-3, -15)) << 4) + ((SMOOTHED(17, -5) < SMOOTHED(11, -10)) << 3) + ((SMOOTHED(-2, 13) < SMOOTHED(-15, 4)) << 2) + ((SMOOTHED(-2, -1) < SMOOTHED(4, -23)) << 1) + ((SMOOTHED(-16, 3) < SMOOTHED(-7, -14)) << 0));
|
||||
desc[54] = (uchar)(((SMOOTHED(-3, -5) < SMOOTHED(-10, -9)) << 7) + ((SMOOTHED(-5, 3) < SMOOTHED(-2, -1)) << 6) + ((SMOOTHED(-1, 4) < SMOOTHED(1, 8)) << 5) + ((SMOOTHED(12, 9) < SMOOTHED(9, -14)) << 4) + ((SMOOTHED(-9, 17) < SMOOTHED(-3, 0)) << 3) + ((SMOOTHED(5, 4) < SMOOTHED(13, -6)) << 2) + ((SMOOTHED(-1, -8) < SMOOTHED(19, 10)) << 1) + ((SMOOTHED(8, -5) < SMOOTHED(-15, 2)) << 0));
|
||||
desc[55] = (uchar)(((SMOOTHED(-12, -9) < SMOOTHED(-4, -5)) << 7) + ((SMOOTHED(12, 0) < SMOOTHED(24, 4)) << 6) + ((SMOOTHED(8, -2) < SMOOTHED(14, 4)) << 5) + ((SMOOTHED(8, -4) < SMOOTHED(-7, 16)) << 4) + ((SMOOTHED(5, -1) < SMOOTHED(-8, -4)) << 3) + ((SMOOTHED(-2, 18) < SMOOTHED(-5, 17)) << 2) + ((SMOOTHED(8, -2) < SMOOTHED(-9, -2)) << 1) + ((SMOOTHED(3, -7) < SMOOTHED(1, -6)) << 0));
|
||||
desc[56] = (uchar)(((SMOOTHED(-5, -22) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, -10) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(-3, -13) < SMOOTHED(3, 9)) << 5) + ((SMOOTHED(-4, -1) < SMOOTHED(-1, 0)) << 4) + ((SMOOTHED(-7, -21) < SMOOTHED(12, -19)) << 3) + ((SMOOTHED(-8, 8) < SMOOTHED(24, 8)) << 2) + ((SMOOTHED(12, -6) < SMOOTHED(-2, 3)) << 1) + ((SMOOTHED(-5, -11) < SMOOTHED(-22, -4)) << 0));
|
||||
desc[57] = (uchar)(((SMOOTHED(-3, 5) < SMOOTHED(-4, 4)) << 7) + ((SMOOTHED(-16, 24) < SMOOTHED(7, -9)) << 6) + ((SMOOTHED(-10, 23) < SMOOTHED(-9, 18)) << 5) + ((SMOOTHED(1, 12) < SMOOTHED(17, 21)) << 4) + ((SMOOTHED(24, -6) < SMOOTHED(-3, -11)) << 3) + ((SMOOTHED(-7, 17) < SMOOTHED(1, -6)) << 2) + ((SMOOTHED(4, 4) < SMOOTHED(2, -7)) << 1) + ((SMOOTHED(14, 6) < SMOOTHED(-12, 3)) << 0));
|
||||
desc[58] = (uchar)(((SMOOTHED(-6, 0) < SMOOTHED(-16, 13)) << 7) + ((SMOOTHED(-10, 5) < SMOOTHED(7, 12)) << 6) + ((SMOOTHED(5, 2) < SMOOTHED(6, -3)) << 5) + ((SMOOTHED(7, 0) < SMOOTHED(-23, 1)) << 4) + ((SMOOTHED(15, -5) < SMOOTHED(1, 14)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(6, 6)) << 2) + ((SMOOTHED(6, -9) < SMOOTHED(-9, 12)) << 1) + ((SMOOTHED(4, -2) < SMOOTHED(-4, 7)) << 0));
|
||||
desc[59] = (uchar)(((SMOOTHED(-4, -5) < SMOOTHED(4, 4)) << 7) + ((SMOOTHED(-13, 0) < SMOOTHED(6, -10)) << 6) + ((SMOOTHED(2, -12) < SMOOTHED(-6, -3)) << 5) + ((SMOOTHED(16, 0) < SMOOTHED(-3, 3)) << 4) + ((SMOOTHED(5, -14) < SMOOTHED(6, 11)) << 3) + ((SMOOTHED(5, 11) < SMOOTHED(0, -13)) << 2) + ((SMOOTHED(7, 5) < SMOOTHED(-1, -5)) << 1) + ((SMOOTHED(12, 4) < SMOOTHED(6, 10)) << 0));
|
||||
desc[60] = (uchar)(((SMOOTHED(-10, 4) < SMOOTHED(-1, -11)) << 7) + ((SMOOTHED(4, 10) < SMOOTHED(-14, 5)) << 6) + ((SMOOTHED(11, -14) < SMOOTHED(-13, 0)) << 5) + ((SMOOTHED(2, 8) < SMOOTHED(12, 24)) << 4) + ((SMOOTHED(-1, 3) < SMOOTHED(-1, 2)) << 3) + ((SMOOTHED(9, -14) < SMOOTHED(-23, 3)) << 2) + ((SMOOTHED(-8, -6) < SMOOTHED(0, 9)) << 1) + ((SMOOTHED(-15, 14) < SMOOTHED(10, -10)) << 0));
|
||||
desc[61] = (uchar)(((SMOOTHED(-10, -6) < SMOOTHED(-7, -5)) << 7) + ((SMOOTHED(11, 5) < SMOOTHED(-3, -15)) << 6) + ((SMOOTHED(1, 0) < SMOOTHED(1, 8)) << 5) + ((SMOOTHED(-11, -6) < SMOOTHED(-4, -18)) << 4) + ((SMOOTHED(9, 0) < SMOOTHED(22, -4)) << 3) + ((SMOOTHED(-5, -1) < SMOOTHED(-9, 4)) << 2) + ((SMOOTHED(-20, 2) < SMOOTHED(1, 6)) << 1) + ((SMOOTHED(1, 2) < SMOOTHED(-9, -12)) << 0));
|
||||
desc[62] = (uchar)(((SMOOTHED(5, 15) < SMOOTHED(4, -6)) << 7) + ((SMOOTHED(19, 4) < SMOOTHED(4, 11)) << 6) + ((SMOOTHED(17, -4) < SMOOTHED(-8, -1)) << 5) + ((SMOOTHED(-8, -12) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(11, 9) < SMOOTHED(8, 1)) << 3) + ((SMOOTHED(9, 22) < SMOOTHED(-15, 15)) << 2) + ((SMOOTHED(-7, -7) < SMOOTHED(1, -23)) << 1) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 2)) << 0));
|
||||
desc[63] = (uchar)(((SMOOTHED(3, -5) < SMOOTHED(11, -11)) << 7) + ((SMOOTHED(3, -18) < SMOOTHED(14, -5)) << 6) + ((SMOOTHED(-20, 7) < SMOOTHED(-10, -23)) << 5) + ((SMOOTHED(-2, -5) < SMOOTHED(6, 0)) << 4) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 3) + ((SMOOTHED(-6, -1) < SMOOTHED(14, -2)) << 2) + ((SMOOTHED(-12, -16) < SMOOTHED(15, 6)) << 1) + ((SMOOTHED(-12, -2) < SMOOTHED(3, -19)) << 0));
|
||||
#undef SMOOTHED
|
||||
|
||||
@ -58,7 +58,7 @@ template<typename PatchType, typename SumType>
|
||||
SumType * dX_data = reinterpret_cast<SumType*> (dX.data), *dY_data = reinterpret_cast<SumType*> (dY.data);
|
||||
SumType * dX_data_end = dX_data + 9 * 7;
|
||||
PatchType * patch_data = reinterpret_cast<PatchType*> (patch.data);
|
||||
int two_row_offset = 2 * patch.step1();
|
||||
int two_row_offset = (int)(2 * patch.step1());
|
||||
std::vector<int>::const_iterator dX_offset = dX_offsets.begin(), dY_offset = dY_offsets.begin();
|
||||
// Compute the differences
|
||||
for (; dX_data != dX_data_end; ++dX_data, ++dY_data, ++dX_offset, ++dY_offset)
|
||||
@ -127,11 +127,11 @@ HarrisResponse::HarrisResponse(const cv::Mat& image, double k) :
|
||||
dX_offsets_.resize(7 * 9);
|
||||
dY_offsets_.resize(7 * 9);
|
||||
std::vector<int>::iterator dX_offsets = dX_offsets_.begin(), dY_offsets = dY_offsets_.begin();
|
||||
unsigned int image_step = (unsigned int)image.step1();
|
||||
for (size_t y = 0; y <= 6 * image_step; y += image_step)
|
||||
int x, y, image_step = (int)image.step1();
|
||||
for (y = 0; y <= 6 * image_step; y += image_step)
|
||||
{
|
||||
int dX_offset = y + 2, dY_offset = y + 2 * image_step;
|
||||
for (size_t x = 0; x <= 6; ++x)
|
||||
for (x = 0; x <= 6; ++x)
|
||||
{
|
||||
*(dX_offsets++) = dX_offset++;
|
||||
*(dY_offsets++) = dY_offset++;
|
||||
@ -140,10 +140,10 @@ HarrisResponse::HarrisResponse(const cv::Mat& image, double k) :
|
||||
*(dY_offsets++) = dY_offset++;
|
||||
}
|
||||
|
||||
for (size_t y = 7 * image_step; y <= 8 * image_step; y += image_step)
|
||||
for (y = 7 * image_step; y <= 8 * image_step; y += image_step)
|
||||
{
|
||||
int dX_offset = y + 2;
|
||||
for (size_t x = 0; x <= 6; ++x)
|
||||
for (x = 0; x <= 6; ++x)
|
||||
*(dX_offsets++) = dX_offset++;
|
||||
}
|
||||
}
|
||||
@ -405,16 +405,17 @@ private:
|
||||
}
|
||||
|
||||
int half_kernel = ORB::kKernelWidth / 2;
|
||||
for (unsigned int i = 0; i < 512; ++i)
|
||||
for (int i = 0; i < 512; ++i)
|
||||
{
|
||||
int center = *(pattern_data + 2 * i) + normalized_step_ * (*(pattern_data + 2 * i + 1));
|
||||
int center = (int)(*(pattern_data + 2 * i) + normalized_step_ * (*(pattern_data + 2 * i + 1)));
|
||||
int nstep = (int)normalized_step_;
|
||||
// Points in order 01
|
||||
// 32
|
||||
// +1 is added for certain coordinates for the integral image
|
||||
*(relative_pattern_data++) = center - half_kernel - half_kernel * normalized_step_;
|
||||
*(relative_pattern_data++) = center + (half_kernel + 1) - half_kernel * normalized_step_;
|
||||
*(relative_pattern_data++) = center + (half_kernel + 1) + (half_kernel + 1) * normalized_step_;
|
||||
*(relative_pattern_data++) = center - half_kernel + (half_kernel + 1) * normalized_step_;
|
||||
*(relative_pattern_data++) = center - half_kernel - half_kernel * nstep;
|
||||
*(relative_pattern_data++) = center + (half_kernel + 1) - half_kernel * nstep;
|
||||
*(relative_pattern_data++) = center + (half_kernel + 1) + (half_kernel + 1) * nstep;
|
||||
*(relative_pattern_data++) = center - half_kernel + (half_kernel + 1) * nstep;
|
||||
}
|
||||
}
|
||||
|
||||
@ -765,8 +766,8 @@ void ORB::computeIntegralImage(const cv::Mat & image, unsigned int level, cv::Ma
|
||||
integral(image, integral_image, CV_32S);
|
||||
integral_image_steps_.resize(params_.n_levels_, 0);
|
||||
|
||||
unsigned int integral_image_step = integral_image.step1();
|
||||
if (integral_image_steps_[level] == integral_image_step)
|
||||
int integral_image_step = (int)integral_image.step1();
|
||||
if ((int)integral_image_steps_[level] == integral_image_step)
|
||||
return;
|
||||
|
||||
// If the integral image dimensions have changed, recompute everything
|
||||
@ -828,11 +829,11 @@ void ORB::computeDescriptors(const cv::Mat& image, const cv::Mat& integral_image
|
||||
OrbPatterns* patterns = patterns_[level];
|
||||
|
||||
//create the descriptor mat, keypoints.size() rows, BYTES cols
|
||||
descriptors = cv::Mat::zeros(keypoints.size(), kBytes, CV_8UC1);
|
||||
descriptors = cv::Mat::zeros((int)keypoints.size(), kBytes, CV_8UC1);
|
||||
|
||||
for (size_t i = 0; i < keypoints.size(); i++)
|
||||
// look up the test pattern
|
||||
patterns->compute(keypoints[i], integral_image, descriptors.ptr(i));
|
||||
patterns->compute(keypoints[i], integral_image, descriptors.ptr((int)i));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -139,8 +139,8 @@ void CV_FeatureDetectorTest::compareKeypointSets( const vector<KeyPoint>& validK
|
||||
return;
|
||||
}
|
||||
|
||||
int progress = 0, progressCount = validKeypoints.size() * calcKeypoints.size();
|
||||
int badPointCount = 0, commonPointCount = max(validKeypoints.size(), calcKeypoints.size());
|
||||
int progress = 0, progressCount = (int)(validKeypoints.size() * calcKeypoints.size());
|
||||
int badPointCount = 0, commonPointCount = max((int)validKeypoints.size(), (int)calcKeypoints.size());
|
||||
for( size_t v = 0; v < validKeypoints.size(); v++ )
|
||||
{
|
||||
int nearestIdx = -1;
|
||||
@ -148,12 +148,12 @@ void CV_FeatureDetectorTest::compareKeypointSets( const vector<KeyPoint>& validK
|
||||
|
||||
for( size_t c = 0; c < calcKeypoints.size(); c++ )
|
||||
{
|
||||
progress = update_progress( progress, v*calcKeypoints.size() + c, progressCount, 0 );
|
||||
progress = update_progress( progress, (int)(v*calcKeypoints.size() + c), progressCount, 0 );
|
||||
float curDist = (float)norm( calcKeypoints[c].pt - validKeypoints[v].pt );
|
||||
if( curDist < minDist )
|
||||
{
|
||||
minDist = curDist;
|
||||
nearestIdx = c;
|
||||
nearestIdx = (int)c;
|
||||
}
|
||||
}
|
||||
|
||||
@ -256,7 +256,7 @@ static void writeMatInBin( const Mat& mat, const string& filename )
|
||||
fwrite( (void*)&mat.rows, sizeof(int), 1, f );
|
||||
fwrite( (void*)&mat.cols, sizeof(int), 1, f );
|
||||
fwrite( (void*)&type, sizeof(int), 1, f );
|
||||
int dataSize = mat.step * mat.rows * mat.channels();
|
||||
int dataSize = (int)(mat.step * mat.rows * mat.channels());
|
||||
fwrite( (void*)&dataSize, sizeof(int), 1, f );
|
||||
fwrite( (void*)mat.data, 1, dataSize, f );
|
||||
fclose(f);
|
||||
|
||||
@ -107,9 +107,9 @@ void save_header(FILE* stream, const NNIndex<Distance>& index)
|
||||
inline IndexHeader load_header(FILE* stream)
|
||||
{
|
||||
IndexHeader header;
|
||||
int read_size = fread(&header,sizeof(header),1,stream);
|
||||
size_t read_size = fread(&header,sizeof(header),1,stream);
|
||||
|
||||
if (read_size!=1) {
|
||||
if (read_size!=(size_t)1) {
|
||||
throw FLANNException("Invalid index file, cannot read");
|
||||
}
|
||||
|
||||
|
||||
@ -64,10 +64,10 @@ void cv::filterSpeckles( Mat& img, uchar newVal, int maxSpeckleSize, uchar maxDi
|
||||
int width = img.cols, height = img.rows, npixels = width*height;
|
||||
size_t bufSize = npixels*(int)(sizeof(Point2s) + sizeof(int) + sizeof(uchar));
|
||||
if( !_buf.isContinuous() || !_buf.data || _buf.cols*_buf.rows*_buf.elemSize() < bufSize )
|
||||
_buf.create(1, bufSize, CV_8U);
|
||||
_buf.create(1, (int)bufSize, CV_8U);
|
||||
|
||||
uchar* buf = _buf.data;
|
||||
int i, j, dstep = img.step/sizeof(uchar);
|
||||
int i, j, dstep = (int)(img.step/sizeof(uchar));
|
||||
int* labels = (int*)buf;
|
||||
buf += npixels*sizeof(labels[0]);
|
||||
Point2s* wbuf = (Point2s*)buf;
|
||||
|
||||
@ -662,12 +662,12 @@ INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher, testing::Combine(
|
||||
// trainGPU.upload(train);
|
||||
//}
|
||||
//
|
||||
//#define GPU_BFM_TEST(test_name) \
|
||||
// struct CV_GpuBFM_ ##test_name ## _Test : CV_GpuBFMTest \
|
||||
// { \
|
||||
// void test(const GpuMat& query, const GpuMat& train, BruteForceMatcher_GPU_base& matcher); \
|
||||
// }; \
|
||||
// TEST(BruteForceMatcher, test_name) { CV_GpuBFM_ ##test_name ## _Test test; test.safe_run(); } \
|
||||
//#define GPU_BFM_TEST(test_name)
|
||||
// struct CV_GpuBFM_ ##test_name ## _Test : CV_GpuBFMTest
|
||||
// {
|
||||
// void test(const GpuMat& query, const GpuMat& train, BruteForceMatcher_GPU_base& matcher);
|
||||
// };
|
||||
// TEST(BruteForceMatcher, test_name) { CV_GpuBFM_ ##test_name ## _Test test; test.safe_run(); }
|
||||
// void CV_GpuBFM_ ##test_name ## _Test::test(const GpuMat& query, const GpuMat& train, BruteForceMatcher_GPU_base& matcher)
|
||||
//
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@ -673,7 +673,7 @@ public:
|
||||
|
||||
|
||||
//------------------------------------------------
|
||||
STDMETHODIMP QueryInterface(REFIID riid, void **ppvObject){
|
||||
STDMETHODIMP QueryInterface(REFIID, void **ppvObject){
|
||||
*ppvObject = static_cast<ISampleGrabberCB*>(this);
|
||||
return S_OK;
|
||||
}
|
||||
@ -681,7 +681,7 @@ public:
|
||||
|
||||
//This method is meant to have less overhead
|
||||
//------------------------------------------------
|
||||
STDMETHODIMP SampleCB(double Time, IMediaSample *pSample){
|
||||
STDMETHODIMP SampleCB(double, IMediaSample *pSample){
|
||||
if(WaitForSingleObject(hEvent, 0) == WAIT_OBJECT_0) return S_OK;
|
||||
|
||||
HRESULT hr = pSample->GetPointer(&ptrBuffer);
|
||||
@ -705,7 +705,7 @@ public:
|
||||
|
||||
|
||||
//This method is meant to have more overhead
|
||||
STDMETHODIMP BufferCB(double Time, BYTE *pBuffer, long BufferLen){
|
||||
STDMETHODIMP BufferCB(double, BYTE *, long){
|
||||
return E_NOTIMPL;
|
||||
}
|
||||
|
||||
@ -847,7 +847,7 @@ void videoDevice::NukeDownstream(IBaseFilter *pBF){
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
void videoDevice::destroyGraph(){
|
||||
HRESULT hr = NULL;
|
||||
HRESULT hr = NOERROR;
|
||||
//int FuncRetval=0;
|
||||
//int NumFilters=0;
|
||||
|
||||
@ -865,7 +865,8 @@ void videoDevice::destroyGraph(){
|
||||
IBaseFilter * pFilter = NULL;
|
||||
if (pEnum->Next(1, &pFilter, &cFetched) == S_OK)
|
||||
{
|
||||
FILTER_INFO FilterInfo={0};
|
||||
FILTER_INFO FilterInfo;
|
||||
memset(&FilterInfo, 0, sizeof(FilterInfo));
|
||||
hr = pFilter->QueryFilterInfo(&FilterInfo);
|
||||
FilterInfo.pGraph->Release();
|
||||
|
||||
@ -875,7 +876,7 @@ void videoDevice::destroyGraph(){
|
||||
|
||||
while( FilterInfo.achName[count] != 0x00 )
|
||||
{
|
||||
buffer[count] = FilterInfo.achName[count];
|
||||
buffer[count] = (char)FilterInfo.achName[count];
|
||||
count++;
|
||||
}
|
||||
|
||||
@ -914,7 +915,7 @@ videoDevice::~videoDevice(){
|
||||
return;
|
||||
}
|
||||
|
||||
HRESULT HR = NULL;
|
||||
HRESULT HR = NOERROR;
|
||||
|
||||
//Stop the callback and free it
|
||||
if( (sgCallback) && (pGrabber) )
|
||||
@ -1345,7 +1346,7 @@ int videoInput::listDevices(bool silent){
|
||||
int count = 0;
|
||||
int maxLen = sizeof(deviceNames[0])/sizeof(deviceNames[0][0]) - 2;
|
||||
while( varName.bstrVal[count] != 0x00 && count < maxLen) {
|
||||
deviceNames[deviceCounter][count] = varName.bstrVal[count];
|
||||
deviceNames[deviceCounter][count] = (char)varName.bstrVal[count];
|
||||
count++;
|
||||
}
|
||||
deviceNames[deviceCounter][count] = 0;
|
||||
@ -1664,7 +1665,7 @@ bool videoInput::setVideoSettingFilterPct(int deviceID, long Property, float pct
|
||||
float halfStep = (float)stepAmnt * 0.5f;
|
||||
if( mod < halfStep ) rasterValue -= mod;
|
||||
else rasterValue += stepAmnt - mod;
|
||||
printf("RASTER - pctValue is %f - value is %i - step is %i - mod is %i - rasterValue is %i\n", pctValue, value, stepAmnt, mod, rasterValue);
|
||||
printf("RASTER - pctValue is %f - value is %ld - step is %ld - mod is %ld - rasterValue is %ld\n", pctValue, value, stepAmnt, mod, rasterValue);
|
||||
}
|
||||
|
||||
return setVideoSettingFilter(deviceID, Property, rasterValue, Flags, false);
|
||||
@ -1751,7 +1752,7 @@ bool videoInput::setVideoSettingCameraPct(int deviceID, long Property, float pct
|
||||
float halfStep = (float)stepAmnt * 0.5f;
|
||||
if( mod < halfStep ) rasterValue -= mod;
|
||||
else rasterValue += stepAmnt - mod;
|
||||
printf("RASTER - pctValue is %f - value is %i - step is %i - mod is %i - rasterValue is %i\n", pctValue, value, stepAmnt, mod, rasterValue);
|
||||
printf("RASTER - pctValue is %f - value is %ld - step is %ld - mod is %ld - rasterValue is %ld\n", pctValue, value, stepAmnt, mod, rasterValue);
|
||||
}
|
||||
|
||||
return setVideoSettingCamera(deviceID, Property, rasterValue, Flags, false);
|
||||
@ -1866,7 +1867,7 @@ bool videoInput::restartDevice(int id){
|
||||
int nReconnect = VDList[id]->nFramesForReconnect;
|
||||
bool bReconnect = VDList[id]->autoReconnect;
|
||||
|
||||
unsigned long avgFrameTime = VDList[id]->requestedFrameTime;
|
||||
long avgFrameTime = VDList[id]->requestedFrameTime;
|
||||
|
||||
stopDevice(id);
|
||||
|
||||
@ -1914,7 +1915,7 @@ videoInput::~videoInput(){
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
bool videoInput::comInit(){
|
||||
HRESULT hr = NULL;
|
||||
HRESULT hr = NOERROR;
|
||||
|
||||
//no need for us to start com more than once
|
||||
if(comInitCount == 0 ){
|
||||
@ -2273,7 +2274,7 @@ static bool setSizeAndSubtype(videoDevice * VD, int attemptWidth, int attemptHei
|
||||
|
||||
int videoInput::start(int deviceID, videoDevice *VD){
|
||||
|
||||
HRESULT hr = NULL;
|
||||
HRESULT hr = NOERROR;
|
||||
VD->myID = deviceID;
|
||||
VD->setupStarted = true;
|
||||
CAPTURE_MODE = PIN_CATEGORY_CAPTURE; //Don't worry - it ends up being preview (which is faster)
|
||||
|
||||
@ -185,7 +185,7 @@ bool TiffDecoder::readData( Mat& img )
|
||||
TIFFGetField( tif, TIFFTAG_BITSPERSAMPLE, &bpp );
|
||||
TIFFGetField( tif, TIFFTAG_SAMPLESPERPIXEL, &ncn );
|
||||
const int bitsPerByte = 8;
|
||||
int dst_bpp = img.elemSize1() * bitsPerByte;
|
||||
int dst_bpp = (int)(img.elemSize1() * bitsPerByte);
|
||||
|
||||
if(dst_bpp == 8)
|
||||
{
|
||||
@ -427,7 +427,7 @@ bool TiffEncoder::writeLibTiff( const Mat& img, const vector<int>& /*params*/)
|
||||
|
||||
const int bitsPerByte = 8;
|
||||
size_t fileStep = (width * channels * bitsPerChannel) / bitsPerByte;
|
||||
int rowsPerStrip = (1 << 13)/fileStep;
|
||||
int rowsPerStrip = (int)((1 << 13)/fileStep);
|
||||
|
||||
if( rowsPerStrip < 1 )
|
||||
rowsPerStrip = 1;
|
||||
|
||||
@ -124,10 +124,10 @@ class CV_FFmpegWriteSequenceImageTest : public cvtest::BaseTest
|
||||
const int img_c = 480;
|
||||
Size frame_s = Size(img_c, img_r);
|
||||
|
||||
for (size_t k = 1; k <= 5; ++k)
|
||||
for (int k = 1; k <= 5; ++k)
|
||||
{
|
||||
for (size_t ext = 0; ext < 4; ++ext) // 0 - png, 1 - bmp, 2 - pgm, 3 - tiff
|
||||
for (size_t num_channels = 1; num_channels <= 3; num_channels+=2)
|
||||
for (int ext = 0; ext < 4; ++ext) // 0 - png, 1 - bmp, 2 - pgm, 3 - tiff
|
||||
for (int num_channels = 1; num_channels <= 3; num_channels+=2)
|
||||
{
|
||||
ts->printf(ts->LOG, "image type depth:%d channels:%d ext: %s\n", CV_8U, num_channels, ext_from_int(ext).c_str());
|
||||
Mat img(img_r * k, img_c * k, CV_MAKETYPE(CV_8U, num_channels), Scalar::all(0));
|
||||
@ -151,7 +151,7 @@ class CV_FFmpegWriteSequenceImageTest : public cvtest::BaseTest
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t num_channels = 1; num_channels <= 3; num_channels+=2)
|
||||
for (int num_channels = 1; num_channels <= 3; num_channels+=2)
|
||||
{
|
||||
// jpeg
|
||||
ts->printf(ts->LOG, "image type depth:%d channels:%d ext: %s\n", CV_8U, num_channels, ".jpg");
|
||||
@ -178,7 +178,7 @@ class CV_FFmpegWriteSequenceImageTest : public cvtest::BaseTest
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t num_channels = 1; num_channels <= 3; num_channels+=2)
|
||||
for (int num_channels = 1; num_channels <= 3; num_channels+=2)
|
||||
{
|
||||
// tiff
|
||||
ts->printf(ts->LOG, "image type depth:%d channels:%d ext: %s\n", CV_16U, num_channels, ".tiff");
|
||||
|
||||
@ -117,14 +117,14 @@ public:
|
||||
free_nodes.pop_back();
|
||||
}
|
||||
node& n = nodes[ii];
|
||||
int h1 = h.h1 % bins.size();
|
||||
int h1 = (int)(h.h1 % bins.size());
|
||||
n.i = i;
|
||||
n.h2 = h.h2;
|
||||
n.next = bins[h1];
|
||||
bins[h1] = ii;
|
||||
}
|
||||
virtual void hash_remove(lsh_hash h, int /*l*/, int i) {
|
||||
int h1 = h.h1 % bins.size();
|
||||
int h1 = (int)(h.h1 % bins.size());
|
||||
for (int ii = bins[h1], iin, iip = -1; ii != -1; iip = ii, ii = iin) {
|
||||
iin = nodes[ii].next;
|
||||
if (nodes[ii].h2 == h.h2 && nodes[ii].i == i) {
|
||||
@ -137,7 +137,7 @@ public:
|
||||
}
|
||||
}
|
||||
virtual int hash_lookup(lsh_hash h, int /*l*/, int* ret_i, int ret_i_max) {
|
||||
int h1 = h.h1 % bins.size();
|
||||
int h1 = (int)(h.h1 % bins.size());
|
||||
int k = 0;
|
||||
for (int ii = bins[h1]; ii != -1 && k < ret_i_max; ii = nodes[ii].next)
|
||||
if (nodes[ii].h2 == h.h2)
|
||||
|
||||
@ -388,7 +388,7 @@ void CV_ColorCvtBaseTest::convert_backward( const Mat& src, const Mat& dst, Mat&
|
||||
else
|
||||
{
|
||||
int i, j, k;
|
||||
int elem_size = src.elemSize(), elem_size1 = src.elemSize1();
|
||||
int elem_size = (int)src.elemSize(), elem_size1 = (int)src.elemSize1();
|
||||
int width_n = src.cols*elem_size;
|
||||
|
||||
for( i = 0; i < src.rows; i++ )
|
||||
|
||||
@ -224,7 +224,7 @@ int CV_MorphologyBaseTest::prepare_test_case( int test_case_idx )
|
||||
{
|
||||
eldata.resize(aperture_size.width*aperture_size.height);
|
||||
uchar* src = test_mat[INPUT][1].data;
|
||||
int srcstep = test_mat[INPUT][1].step;
|
||||
int srcstep = (int)test_mat[INPUT][1].step;
|
||||
int i, j, nonzero = 0;
|
||||
|
||||
for( i = 0; i < aperture_size.height; i++ )
|
||||
@ -901,7 +901,7 @@ static void test_medianFilter( const Mat& src, Mat& dst, int m )
|
||||
vector<int> col_buf(m+1);
|
||||
vector<median_pair> _buf0(m*m+1), _buf1(m*m+1);
|
||||
median_pair *buf0 = &_buf0[0], *buf1 = &_buf1[0];
|
||||
int step = src.step/src.elemSize();
|
||||
int step = (int)(src.step/src.elemSize());
|
||||
|
||||
assert( src.rows == dst.rows + m - 1 && src.cols == dst.cols + m - 1 &&
|
||||
src.type() == dst.type() && src.type() == CV_8UC1 );
|
||||
@ -1663,10 +1663,10 @@ static void test_integral( const Mat& img, Mat* sum, Mat* sqsum, Mat* tilted )
|
||||
double* sdata = sum->ptr<double>();
|
||||
double* sqdata = sqsum ? sqsum->ptr<double>() : 0;
|
||||
double* tdata = tilted ? tilted->ptr<double>() : 0;
|
||||
int step = img.step/sizeof(data[0]);
|
||||
int sstep = sum->step/sizeof(sdata[0]);
|
||||
int sqstep = sqsum ? sqsum->step/sizeof(sqdata[0]) : 0;
|
||||
int tstep = tilted ? tilted->step/sizeof(tdata[0]) : 0;
|
||||
int step = (int)(img.step/sizeof(data[0]));
|
||||
int sstep = (int)(sum->step/sizeof(sdata[0]));
|
||||
int sqstep = sqsum ? (int)(sqsum->step/sizeof(sqdata[0])) : 0;
|
||||
int tstep = tilted ? (int)(tilted->step/sizeof(tdata[0])) : 0;
|
||||
Size size = img.size();
|
||||
|
||||
memset( sdata, 0, (size.width+1)*sizeof(sdata[0]) );
|
||||
|
||||
@ -347,7 +347,7 @@ static void test_remap( const Mat& src, Mat& dst, const Mat& mapx, const Mat& ma
|
||||
uchar* sptr0 = src.data;
|
||||
int depth = src.depth(), cn = src.channels();
|
||||
int elem_size = (int)src.elemSize();
|
||||
int step = src.step / CV_ELEM_SIZE(depth);
|
||||
int step = (int)(src.step / CV_ELEM_SIZE(depth));
|
||||
int delta;
|
||||
|
||||
if( interpolation != CV_INTER_CUBIC )
|
||||
@ -1100,7 +1100,7 @@ void CV_UndistortMapTest::prepare_to_validation( int )
|
||||
static void
|
||||
test_getQuadrangeSubPix( const Mat& src, Mat& dst, double* a )
|
||||
{
|
||||
int sstep = src.step / sizeof(float);
|
||||
int sstep = (int)(src.step / sizeof(float));
|
||||
int scols = src.cols, srows = src.rows;
|
||||
|
||||
CV_Assert( src.depth() == CV_32F && src.type() == dst.type() );
|
||||
|
||||
@ -314,7 +314,15 @@ public:
|
||||
};
|
||||
|
||||
template<> CV_EXPORTS void Ptr<CvHaarClassifierCascade>::delete_obj();
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
CASCADE_DO_CANNY_PRUNING=1,
|
||||
CASCADE_SCALE_IMAGE=2,
|
||||
CASCADE_FIND_BIGGEST_OBJECT=4,
|
||||
CASCADE_DO_ROUGH_SEARCH=8
|
||||
};
|
||||
|
||||
class CV_EXPORTS_W CascadeClassifier
|
||||
{
|
||||
public:
|
||||
|
||||
@ -173,7 +173,7 @@ public:
|
||||
densityKernel = densKer;
|
||||
weightsV = wV;
|
||||
positionsV = posV;
|
||||
positionsCount = posV.size();
|
||||
positionsCount = (int)posV.size();
|
||||
meanshiftV.resize(positionsCount);
|
||||
distanceV.resize(positionsCount);
|
||||
modeEps = modeEps;
|
||||
@ -316,7 +316,7 @@ protected:
|
||||
static void groupRectangles_meanshift(vector<Rect>& rectList, double detectThreshold, vector<double>* foundWeights,
|
||||
vector<double>& scales, Size winDetSize)
|
||||
{
|
||||
int detectionCount = rectList.size();
|
||||
int detectionCount = (int)rectList.size();
|
||||
vector<Point3d> hits(detectionCount), resultHits;
|
||||
vector<double> hitWeights(detectionCount), resultWeights;
|
||||
Point2d hitCenter;
|
||||
@ -1080,7 +1080,7 @@ struct CascadeClassifierInvoker
|
||||
if( rejectLevels )
|
||||
{
|
||||
if( result == 1 )
|
||||
result = -1*classifier->data.stages.size();
|
||||
result = -(int)classifier->data.stages.size();
|
||||
if( classifier->data.stages.size() + result < 4 )
|
||||
{
|
||||
rectangles->push_back(Rect(cvRound(x*scalingFactor), cvRound(y*scalingFactor), winSize.width, winSize.height));
|
||||
|
||||
@ -191,6 +191,7 @@ CvMat *Sampler::extract()
|
||||
return r;
|
||||
}
|
||||
|
||||
#if CV_SSE2
|
||||
static void apron(CvMat *v)
|
||||
{
|
||||
int r = v->rows;
|
||||
@ -331,11 +332,12 @@ static deque<CvPoint> trailto(CvMat *v, int x, int y, CvMat *terminal)
|
||||
y += yd;
|
||||
}
|
||||
|
||||
int l = r.size() * 9 / 10;
|
||||
int l = (int)(r.size() * 9 / 10);
|
||||
while (l--)
|
||||
r.pop_front();
|
||||
return r;
|
||||
}
|
||||
#endif
|
||||
|
||||
deque <CvDataMatrixCode> cvFindDataMatrix(CvMat *im)
|
||||
{
|
||||
|
||||
@ -508,11 +508,11 @@ int getMaxFilterDims(const CvLSVMFilterObject **filters, int kComponents,
|
||||
componentIndex = kPartFilters[0] + 1;
|
||||
for (i = 1; i < kComponents; i++)
|
||||
{
|
||||
if (filters[componentIndex]->sizeX > *maxXBorder)
|
||||
if ((unsigned)filters[componentIndex]->sizeX > *maxXBorder)
|
||||
{
|
||||
*maxXBorder = filters[componentIndex]->sizeX;
|
||||
}
|
||||
if (filters[componentIndex]->sizeY > *maxYBorder)
|
||||
if ((unsigned)filters[componentIndex]->sizeY > *maxYBorder)
|
||||
{
|
||||
*maxYBorder = filters[componentIndex]->sizeY;
|
||||
}
|
||||
|
||||
@ -202,8 +202,7 @@ int getFFTImageFilterObject(const CvLSVMFilterObject *filter,
|
||||
int mapDimX, int mapDimY,
|
||||
CvLSVMFftImage **image)
|
||||
{
|
||||
unsigned int i, mapSize, filterSize;
|
||||
int res;
|
||||
int i, mapSize, filterSize, res;
|
||||
float *newFilter, *rot2PIFilter;
|
||||
|
||||
filterSize = filter->sizeX * filter->sizeY;
|
||||
|
||||
@ -266,7 +266,7 @@ static bool pyopencv_to(PyObject *o, Scalar& s, const char *name = "<unknown>")
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
if (PyFloat_Check(item) || PyInt_Check(item)) {
|
||||
s[i] = PyFloat_AsDouble(item);
|
||||
s[(int)i] = PyFloat_AsDouble(item);
|
||||
} else {
|
||||
failmsg("Scalar value for argument '%s' is not numeric", name);
|
||||
return false;
|
||||
|
||||
@ -262,7 +262,7 @@ static PyObject *iplimage_tostring(PyObject *self, PyObject *args)
|
||||
bps = 8;
|
||||
break;
|
||||
default:
|
||||
return (PyObject*)failmsg("Unrecognised depth %d", i->depth);
|
||||
return failmsg("Unrecognised depth %d", i->depth), 0;
|
||||
}
|
||||
int bpl = i->width * i->nChannels * bps;
|
||||
if (PyString_Check(pc->data) && bpl == i->widthStep && pc->offset == 0 && ((bpl * i->height) == what_size(pc->data))) {
|
||||
@ -417,7 +417,7 @@ static PyObject *cvmat_tostring(PyObject *self, PyObject *args)
|
||||
bps = CV_MAT_CN(m->type) * 8;
|
||||
break;
|
||||
default:
|
||||
return (PyObject*)failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type));
|
||||
return failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type)), 0;
|
||||
}
|
||||
|
||||
int bpl = m->cols * bps; // bytes per line
|
||||
@ -744,15 +744,14 @@ static PyObject *cvmatnd_tostring(PyObject *self, PyObject *args)
|
||||
bps = CV_MAT_CN(m->type) * 8;
|
||||
break;
|
||||
default:
|
||||
return (PyObject*)failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type));
|
||||
return failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type)), 0;
|
||||
}
|
||||
|
||||
int l = bps;
|
||||
for (int d = 0; d < m->dims; d++) {
|
||||
int d, l = bps;
|
||||
for (d = 0; d < m->dims; d++) {
|
||||
l *= m->dim[d].size;
|
||||
}
|
||||
int i[CV_MAX_DIM];
|
||||
int d;
|
||||
for (d = 0; d < m->dims; d++) {
|
||||
i[d] = 0;
|
||||
}
|
||||
@ -1120,7 +1119,7 @@ static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
|
||||
switch (CV_SEQ_ELTYPE(ps->a)) {
|
||||
|
||||
case CV_SEQ_ELTYPE_POINT:
|
||||
pt = CV_GET_SEQ_ELEM(CvPoint, ps->a, i);
|
||||
pt = CV_GET_SEQ_ELEM(CvPoint, ps->a, (int)i);
|
||||
return Py_BuildValue("ii", pt->x, pt->y);
|
||||
|
||||
case CV_SEQ_ELTYPE_GENERIC:
|
||||
@ -1128,14 +1127,14 @@ static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
|
||||
case sizeof(CvQuadEdge2D):
|
||||
{
|
||||
cvsubdiv2dedge_t *r = PyObject_NEW(cvsubdiv2dedge_t, &cvsubdiv2dedge_Type);
|
||||
r->a = (CvSubdiv2DEdge)CV_GET_SEQ_ELEM(CvQuadEdge2D, ps->a, i);
|
||||
r->a = (CvSubdiv2DEdge)CV_GET_SEQ_ELEM(CvQuadEdge2D, ps->a, (int)i);
|
||||
r->container = ps->container;
|
||||
Py_INCREF(r->container);
|
||||
return (PyObject*)r;
|
||||
}
|
||||
case sizeof(CvConnectedComp):
|
||||
{
|
||||
CvConnectedComp *cc = CV_GET_SEQ_ELEM(CvConnectedComp, ps->a, i);
|
||||
CvConnectedComp *cc = CV_GET_SEQ_ELEM(CvConnectedComp, ps->a, (int)i);
|
||||
return FROM_CvConnectedComp(*cc);
|
||||
}
|
||||
default:
|
||||
@ -1143,22 +1142,22 @@ static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
|
||||
printf("KIND %d\n", CV_SEQ_KIND(ps->a));
|
||||
assert(0);
|
||||
}
|
||||
return PyInt_FromLong(*CV_GET_SEQ_ELEM(unsigned char, ps->a, i));
|
||||
return PyInt_FromLong(*CV_GET_SEQ_ELEM(unsigned char, ps->a, (int)i));
|
||||
|
||||
case CV_SEQ_ELTYPE_PTR:
|
||||
case CV_SEQ_ELTYPE_INDEX:
|
||||
return PyInt_FromLong(*CV_GET_SEQ_ELEM(int, ps->a, i));
|
||||
return PyInt_FromLong(*CV_GET_SEQ_ELEM(int, ps->a, (int)i));
|
||||
|
||||
case CV_32SC4:
|
||||
pp = CV_GET_SEQ_ELEM(pointpair, ps->a, i);
|
||||
pp = CV_GET_SEQ_ELEM(pointpair, ps->a, (int)i);
|
||||
return Py_BuildValue("(ii),(ii)", pp->a.x, pp->a.y, pp->b.x, pp->b.y);
|
||||
|
||||
case CV_32FC2:
|
||||
pt2 = CV_GET_SEQ_ELEM(CvPoint2D32f, ps->a, i);
|
||||
pt2 = CV_GET_SEQ_ELEM(CvPoint2D32f, ps->a, (int)i);
|
||||
return Py_BuildValue("ff", pt2->x, pt2->y);
|
||||
|
||||
case CV_SEQ_ELTYPE_POINT3D:
|
||||
pt3 = CV_GET_SEQ_ELEM(CvPoint3D32f, ps->a, i);
|
||||
pt3 = CV_GET_SEQ_ELEM(CvPoint3D32f, ps->a, (int)i);
|
||||
return Py_BuildValue("fff", pt3->x, pt3->y, pt3->z);
|
||||
|
||||
default:
|
||||
@ -1173,9 +1172,9 @@ static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
|
||||
static PyObject* cvseq_map_getitem(PyObject *o, PyObject *item)
|
||||
{
|
||||
if (PyInt_Check(item)) {
|
||||
long i = PyInt_AS_LONG(item);
|
||||
int i = (int)PyInt_AS_LONG(item);
|
||||
if (i < 0)
|
||||
i += cvseq_seq_length(o);
|
||||
i += (int)cvseq_seq_length(o);
|
||||
return cvseq_seq_getitem(o, i);
|
||||
} else if (PySlice_Check(item)) {
|
||||
Py_ssize_t start, stop, step, slicelength, cur, i;
|
||||
@ -1703,13 +1702,13 @@ static int convert_to_pts_npts_contours(PyObject *o, pts_npts_contours *dst, con
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->contours = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->contours = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->pts = new CvPoint*[dst->contours];
|
||||
dst->npts = new int[dst->contours];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
if (!convert_to_CvPointPTR(PySequence_Fast_GET_ITEM(fi, i), &dst->pts[i], name))
|
||||
return 0;
|
||||
dst->npts[i] = PySequence_Size(PySequence_Fast_GET_ITEM(fi, i)); // safe because convert_ just succeeded
|
||||
dst->npts[i] = (int)PySequence_Size(PySequence_Fast_GET_ITEM(fi, i)); // safe because convert_ just succeeded
|
||||
}
|
||||
Py_DECREF(fi);
|
||||
return 1;
|
||||
@ -1772,13 +1771,13 @@ static int convert_to_cvarrseq(PyObject *o, cvarrseq *dst, const char *name = "n
|
||||
return failmsg("All elements of sequence '%s' must be same size", name);
|
||||
}
|
||||
assert(size != -1);
|
||||
CvMat *mt = cvCreateMat((int)PySequence_Fast_GET_SIZE(fi), 1, CV_32SC(size));
|
||||
CvMat *mt = cvCreateMat((int)PySequence_Fast_GET_SIZE(fi), 1, CV_32SC((int)size));
|
||||
dst->freemat = true; // dealloc this mat when done
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *e = PySequence_Fast_GET_ITEM(fi, i);
|
||||
PyObject *fe = PySequence_Fast(e, name);
|
||||
assert(fe != NULL);
|
||||
int *pdst = (int*)cvPtr2D(mt, i, 0);
|
||||
int *pdst = (int*)cvPtr2D(mt, (int)i, 0);
|
||||
for (Py_ssize_t j = 0; j < size; j++) {
|
||||
PyObject *num = PySequence_Fast_GET_ITEM(fe, j);
|
||||
if (!PyNumber_Check(num)) {
|
||||
@ -1806,7 +1805,7 @@ static int convert_to_cvarr_count(PyObject *o, cvarr_count *dst, const char *nam
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->cvarr = new CvArr*[dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
if (!convert_to_CvArr(PySequence_Fast_GET_ITEM(fi, i), &dst->cvarr[i], name))
|
||||
@ -1827,7 +1826,7 @@ static int convert_to_intpair(PyObject *o, intpair *dst, const char *name = "no_
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->pairs = new int[2 * dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -1865,7 +1864,7 @@ static int convert_to_floats(PyObject *o, floats *dst, const char *name = "no_na
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->f = new float[dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -1897,7 +1896,7 @@ static int convert_to_CvPoints(PyObject *o, CvPoints *dst, const char *name = "n
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->p = new CvPoint[dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -1916,7 +1915,7 @@ static int convert_to_CvPoint3D32fs(PyObject *o, CvPoint3D32fs *dst, const char
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->p = new CvPoint3D32f[dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -1935,7 +1934,7 @@ static int convert_to_CvPoint2D32fs(PyObject *o, CvPoint2D32fs *dst, const char
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->p = new CvPoint2D32f[dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -1954,7 +1953,7 @@ static int convert_to_ints(PyObject *o, ints *dst, const char *name = "no_name")
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->i = new int[dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -1973,7 +1972,7 @@ static int convert_to_ints0(PyObject *o, ints0 *dst, const char *name = "no_name
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->i = new int[dst->count + 1];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -1997,9 +1996,9 @@ static int convert_to_dim(PyObject *item, int i, dims *dst, CvArr *cva, const ch
|
||||
if (PySlice_Check(item)) {
|
||||
Py_ssize_t start, stop, step, slicelength;
|
||||
PySlice_GetIndicesEx((PySliceObject*)item, cvGetDimSize(cva, i), &start, &stop, &step, &slicelength);
|
||||
dst->i[i] = start;
|
||||
dst->step[i] = step;
|
||||
dst->length[i] = slicelength;
|
||||
dst->i[i] = (int)start;
|
||||
dst->step[i] = (int)step;
|
||||
dst->length[i] = (int)slicelength;
|
||||
} else {
|
||||
int index = PyInt_AsLong(item);
|
||||
if (0 <= index)
|
||||
@ -2023,13 +2022,13 @@ static int convert_to_dims(PyObject *o, dims *dst, CvArr *cva, const char *name
|
||||
PyErr_SetString(PyExc_TypeError, "Expected tuple for index");
|
||||
return 0;
|
||||
}
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
if (i >= cvGetDims(cva)) {
|
||||
return failmsg("Access specifies %d dimensions, but array only has %d", PySequence_Fast_GET_SIZE(fi), cvGetDims(cva));
|
||||
}
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
if (!convert_to_dim(item, i, dst, cva, name))
|
||||
if (!convert_to_dim(item, (int)i, dst, cva, name))
|
||||
return 0;
|
||||
}
|
||||
Py_DECREF(fi);
|
||||
@ -2046,7 +2045,7 @@ static int convert_to_IplImages(PyObject *o, IplImages *dst, const char *name =
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->ims = new IplImage*[dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -2066,7 +2065,7 @@ static int convert_to_CvArrs(PyObject *o, CvArrs *dst, const char *name = "no_na
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
dst->count = PySequence_Fast_GET_SIZE(fi);
|
||||
dst->count = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
dst->ims = new CvArr*[dst->count];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -2082,7 +2081,7 @@ static int convert_to_CvArrs(PyObject *o, CvArrs *dst, const char *name = "no_na
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
Py_ssize_t sz = PySequence_Fast_GET_SIZE(fi);
|
||||
Py_ssize_t sz = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
float **r = new float*[sz];
|
||||
for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -2839,20 +2838,20 @@ static PyObject *fromarray(PyObject *o, int allowND)
|
||||
cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
|
||||
if (pai->nd == 2) {
|
||||
if (pai->strides[1] != pai->itemsize) {
|
||||
return (PyObject*)failmsg("cv.fromarray array can only accept arrays with contiguous data");
|
||||
return failmsg("cv.fromarray array can only accept arrays with contiguous data"), 0;
|
||||
}
|
||||
ERRWRAP(m->a = cvCreateMatHeader(pai->shape[0], pai->shape[1], type));
|
||||
m->a->step = pai->strides[0];
|
||||
ERRWRAP(m->a = cvCreateMatHeader((int)pai->shape[0], (int)pai->shape[1], type));
|
||||
m->a->step = (int)pai->strides[0];
|
||||
} else if (pai->nd == 3) {
|
||||
if (pai->shape[2] > CV_CN_MAX) {
|
||||
Py_DECREF(ao);
|
||||
return (PyObject*)failmsg("cv.fromarray too many channels, see allowND argument");
|
||||
return failmsg("cv.fromarray too many channels, see allowND argument"), 0;
|
||||
}
|
||||
ERRWRAP(m->a = cvCreateMatHeader(pai->shape[0], pai->shape[1], type + ((pai->shape[2] - 1) << CV_CN_SHIFT)));
|
||||
m->a->step = pai->strides[0];
|
||||
ERRWRAP(m->a = cvCreateMatHeader((int)pai->shape[0], (int)pai->shape[1], type + ((int)(pai->shape[2] - 1) << CV_CN_SHIFT)));
|
||||
m->a->step = (int)pai->strides[0];
|
||||
} else {
|
||||
Py_DECREF(ao);
|
||||
return (PyObject*)failmsg("cv.fromarray array can be 2D or 3D only, see allowND argument");
|
||||
return failmsg("cv.fromarray array can be 2D or 3D only, see allowND argument"), 0;
|
||||
}
|
||||
m->a->data.ptr = (uchar*)pai->data;
|
||||
//retval = pythonize_foreign_CvMat(m);
|
||||
@ -2863,7 +2862,7 @@ static PyObject *fromarray(PyObject *o, int allowND)
|
||||
int dims[CV_MAX_DIM];
|
||||
int i;
|
||||
for (i = 0; i < pai->nd; i++)
|
||||
dims[i] = pai->shape[i];
|
||||
dims[i] = (int)pai->shape[i];
|
||||
cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
|
||||
ERRWRAP(m->a = cvCreateMatNDHeader(pai->nd, dims, type));
|
||||
m->a->data.ptr = (uchar*)pai->data;
|
||||
@ -2890,7 +2889,7 @@ public:
|
||||
PyObject *fi = PySequence_Fast(o, name);
|
||||
if (fi == NULL)
|
||||
return 0;
|
||||
len = PySequence_Fast_GET_SIZE(fi);
|
||||
len = (int)PySequence_Fast_GET_SIZE(fi);
|
||||
rr = new float*[len];
|
||||
for (Py_ssize_t i = 0; i < len; i++) {
|
||||
PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
|
||||
@ -3019,18 +3018,18 @@ static PyObject *cvarr_GetItem(PyObject *o, PyObject *key)
|
||||
// negative steps are illegal for OpenCV
|
||||
for (int i = 0; i < dd.count; i++) {
|
||||
if (dd.step[i] < 0)
|
||||
return (PyObject*)failmsg("Negative step is illegal");
|
||||
return failmsg("Negative step is illegal"), 0;
|
||||
}
|
||||
|
||||
// zero length illegal for OpenCV
|
||||
for (int i = 0; i < dd.count; i++) {
|
||||
if (dd.length[i] == 0)
|
||||
return (PyObject*)failmsg("Zero sized dimension is illegal");
|
||||
return failmsg("Zero sized dimension is illegal"), 0;
|
||||
}
|
||||
|
||||
// column step can only be 0 or 1
|
||||
if ((dd.step[dd.count-1] != 0) && (dd.step[dd.count-1] != 1))
|
||||
return (PyObject*)failmsg("Column step is illegal");
|
||||
return failmsg("Column step is illegal"), 0;
|
||||
|
||||
if (is_cvmat(o) || is_iplimage(o)) {
|
||||
cvmat_t *sub = PyObject_NEW(cvmat_t, &cvmat_Type);
|
||||
@ -3477,7 +3476,7 @@ static PyObject *pycvSubdiv2DLocate(PyObject *self, PyObject *args)
|
||||
Py_INCREF(Py_None);
|
||||
break;
|
||||
default:
|
||||
return (PyObject*)failmsg("Unexpected loc from cvSubdiv2DLocate");
|
||||
return failmsg("Unexpected loc from cvSubdiv2DLocate"), 0;
|
||||
}
|
||||
return Py_BuildValue("iO", (int)loc, r);
|
||||
}
|
||||
@ -3694,7 +3693,7 @@ static PyObject *shareData(PyObject *donor, CvArr *pdonor, CvMat *precipient)
|
||||
arr_data = ((iplimage_t*)donor)->data;
|
||||
((cvmat_t*)recipient)->offset += ((iplimage_t*)donor)->offset;
|
||||
} else {
|
||||
return (PyObject*)failmsg("Argument 'mat' must be either IplImage or CvMat");
|
||||
return failmsg("Argument 'mat' must be either IplImage or CvMat"), 0;
|
||||
}
|
||||
((cvmat_t*)recipient)->data = arr_data;
|
||||
Py_INCREF(arr_data);
|
||||
|
||||
@ -216,7 +216,7 @@ int ArrayTest::prepare_test_case( int test_case_idx )
|
||||
CvArr* arr = test_array[i][j];
|
||||
test_mat[i][j] = cv::cvarrToMat(arr);
|
||||
if( !test_mat[i][j].empty() )
|
||||
fill_array( test_case_idx, i, j, test_mat[i][j] );
|
||||
fill_array( test_case_idx, (int)i, (int)j, test_mat[i][j] );
|
||||
}
|
||||
}
|
||||
|
||||
@ -304,7 +304,7 @@ int ArrayTest::validate_test_results( int test_case_idx )
|
||||
if( !test_array[i1][j] )
|
||||
continue;
|
||||
|
||||
err_level = get_success_error_level( test_case_idx, i0, j );
|
||||
err_level = get_success_error_level( test_case_idx, i0, (int)j );
|
||||
code = cmpEps( test_mat[i0][j], test_mat[i1][j], &max_diff, err_level, &idx, element_wise_relative_error );
|
||||
|
||||
switch( code )
|
||||
|
||||
@ -177,11 +177,12 @@ void add(const Mat& _a, double alpha, const Mat& _b, double beta,
|
||||
Mat planes[3], buf[3];
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
int i, nplanes = it.nplanes, cn=a.channels();
|
||||
size_t total = planes[0].total(), maxsize = std::min((size_t)12*12*std::max(12/cn, 1), total);
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int cn=a.channels();
|
||||
int total = (int)planes[0].total(), maxsize = std::min(12*12*std::max(12/cn, 1), total);
|
||||
|
||||
CV_Assert(planes[0].rows == 1);
|
||||
buf[0].create(1, (int)maxsize, CV_64FC(cn));
|
||||
buf[0].create(1, maxsize, CV_64FC(cn));
|
||||
if(!b.empty())
|
||||
buf[1].create(1, maxsize, CV_64FC(cn));
|
||||
buf[2].create(1, maxsize, CV_64FC(cn));
|
||||
@ -189,12 +190,12 @@ void add(const Mat& _a, double alpha, const Mat& _b, double beta,
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it)
|
||||
{
|
||||
for( size_t j = 0; j < total; j += maxsize )
|
||||
for( int j = 0; j < total; j += maxsize )
|
||||
{
|
||||
size_t j2 = std::min(j + maxsize, total);
|
||||
Mat apart0 = planes[0].colRange((int)j, (int)j2);
|
||||
Mat cpart0 = planes[2].colRange((int)j, (int)j2);
|
||||
Mat apart = buf[0].colRange(0, (int)(j2 - j));
|
||||
int j2 = std::min(j + maxsize, total);
|
||||
Mat apart0 = planes[0].colRange(j, j2);
|
||||
Mat cpart0 = planes[2].colRange(j, j2);
|
||||
Mat apart = buf[0].colRange(0, j2 - j);
|
||||
|
||||
apart0.convertTo(apart, apart.type(), alpha);
|
||||
size_t k, n = (j2 - j)*cn;
|
||||
@ -291,7 +292,7 @@ void convert(const Mat& src, Mat& dst, int dtype, double alpha, double beta)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total()*planes[0].channels();
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it)
|
||||
{
|
||||
@ -335,7 +336,7 @@ void copy(const Mat& src, Mat& dst, const Mat& mask, bool invertMask)
|
||||
const Mat* arrays[] = {&src, &dst, 0};
|
||||
Mat planes[2];
|
||||
NAryMatIterator it(arrays, planes);
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
size_t planeSize = planes[0].total()*src.elemSize();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -351,7 +352,7 @@ void copy(const Mat& src, Mat& dst, const Mat& mask, bool invertMask)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t j, k, elemSize = src.elemSize(), total = planes[0].total();
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it)
|
||||
{
|
||||
@ -380,7 +381,7 @@ void set(Mat& dst, const Scalar& gamma, const Mat& mask)
|
||||
const Mat* arrays[] = {&dst, 0};
|
||||
Mat plane;
|
||||
NAryMatIterator it(arrays, &plane);
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
size_t j, k, elemSize = dst.elemSize(), planeSize = plane.total()*elemSize;
|
||||
|
||||
for( k = 1; k < elemSize; k++ )
|
||||
@ -412,7 +413,7 @@ void set(Mat& dst, const Scalar& gamma, const Mat& mask)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t j, k, elemSize = dst.elemSize(), total = planes[0].total();
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it)
|
||||
{
|
||||
@ -437,7 +438,7 @@ void insert(const Mat& src, Mat& dst, int coi)
|
||||
const Mat* arrays[] = {&src, &dst, 0};
|
||||
Mat planes[2];
|
||||
NAryMatIterator it(arrays, planes);
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
size_t j, k, size0 = src.elemSize(), size1 = dst.elemSize(), total = planes[0].total();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -462,7 +463,7 @@ void extract(const Mat& src, Mat& dst, int coi)
|
||||
const Mat* arrays[] = {&src, &dst, 0};
|
||||
Mat planes[2];
|
||||
NAryMatIterator it(arrays, planes);
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
size_t j, k, size0 = src.elemSize(), size1 = dst.elemSize(), total = planes[0].total();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -546,7 +547,8 @@ void randUni( RNG& rng, Mat& a, const Scalar& param0, const Scalar& param1 )
|
||||
Mat plane;
|
||||
|
||||
NAryMatIterator it(arrays, &plane);
|
||||
int i, nplanes = it.nplanes, depth = a.depth(), cn = a.channels();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = a.depth(), cn = a.channels();
|
||||
size_t total = plane.total()*cn;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -1017,7 +1019,7 @@ static void setpos( const Mat& mtx, vector<int>& pos, size_t idx )
|
||||
for( int i = mtx.dims-1; i >= 0; i-- )
|
||||
{
|
||||
int sz = mtx.size[i]*(i == mtx.dims-1 ? mtx.channels() : 1);
|
||||
pos[i] = idx % sz;
|
||||
pos[i] = (int)(idx % sz);
|
||||
idx /= sz;
|
||||
}
|
||||
}
|
||||
@ -1038,7 +1040,8 @@ void minMaxLoc(const Mat& src, double* _minval, double* _maxval,
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t startidx = 1, total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = src.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src.depth();
|
||||
double maxval = depth < CV_32F ? INT_MIN : depth == CV_32F ? -FLT_MAX : -DBL_MAX;
|
||||
double minval = depth < CV_32F ? INT_MAX : depth == CV_32F ? FLT_MAX : DBL_MAX;
|
||||
size_t maxidx = 0, minidx = 0;
|
||||
@ -1220,8 +1223,8 @@ double norm(const Mat& src, int normType, const Mat& mask)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = src.depth();
|
||||
int cn = planes[0].channels();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src.depth(), cn = planes[0].channels();
|
||||
double result = 0;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -1272,8 +1275,8 @@ double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = src1.depth();
|
||||
int cn = planes[0].channels();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src1.depth(), cn = planes[0].channels();
|
||||
double result = 0;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -1332,7 +1335,8 @@ double crossCorr(const Mat& src1, const Mat& src2)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total()*planes[0].channels();
|
||||
int i, nplanes = it.nplanes, depth = src1.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src1.depth();
|
||||
double result = 0;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -1394,14 +1398,14 @@ logicOpS_(const uchar* src, const uchar* scalar, uchar* dst, size_t total, char
|
||||
if( c == '&' )
|
||||
for( i = 0; i < total; i += blockSize, dst += blockSize, src += blockSize )
|
||||
{
|
||||
size_t sz = std::min(total - i, blockSize);
|
||||
size_t sz = MIN(total - i, blockSize);
|
||||
for( j = 0; j < sz; j++ )
|
||||
dst[j] = src[j] & scalar[j];
|
||||
}
|
||||
else if( c == '|' )
|
||||
for( i = 0; i < total; i += blockSize, dst += blockSize, src += blockSize )
|
||||
{
|
||||
size_t sz = std::min(total - i, blockSize);
|
||||
size_t sz = MIN(total - i, blockSize);
|
||||
for( j = 0; j < sz; j++ )
|
||||
dst[j] = src[j] | scalar[j];
|
||||
}
|
||||
@ -1409,7 +1413,7 @@ logicOpS_(const uchar* src, const uchar* scalar, uchar* dst, size_t total, char
|
||||
{
|
||||
for( i = 0; i < total; i += blockSize, dst += blockSize, src += blockSize )
|
||||
{
|
||||
size_t sz = std::min(total - i, blockSize);
|
||||
size_t sz = MIN(total - i, blockSize);
|
||||
for( j = 0; j < sz; j++ )
|
||||
dst[j] = src[j] ^ scalar[j];
|
||||
}
|
||||
@ -1430,7 +1434,7 @@ void logicOp( const Mat& src1, const Mat& src2, Mat& dst, char op )
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total()*planes[0].elemSize();
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -1452,9 +1456,9 @@ void logicOp(const Mat& src, const Scalar& s, Mat& dst, char op)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total()*planes[0].elemSize();
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
double buf[12];
|
||||
scalarToRawData(s, buf, src.type(), 96/planes[0].elemSize1());
|
||||
scalarToRawData(s, buf, src.type(), (int)(96/planes[0].elemSize1()));
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -1547,7 +1551,8 @@ void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = src1.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src1.depth();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -1593,7 +1598,8 @@ void compare(const Mat& src, double value, Mat& dst, int cmpop)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = src.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src.depth();
|
||||
int ivalue = saturate_cast<int>(value);
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -1721,7 +1727,8 @@ bool cmpUlps(const Mat& src1, const Mat& src2, int imaxDiff, double* _realmaxdif
|
||||
Mat planes[2];
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total()*planes[0].channels();
|
||||
int i, nplanes = it.nplanes, depth = src1.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src1.depth();
|
||||
size_t startidx = 1, idx = 0;
|
||||
if(_realmaxdiff)
|
||||
*_realmaxdiff = 0;
|
||||
@ -1806,7 +1813,8 @@ int check( const Mat& a, double fmin, double fmax, vector<int>* _idx )
|
||||
Mat plane;
|
||||
NAryMatIterator it(arrays, &plane);
|
||||
size_t total = plane.total()*plane.channels();
|
||||
int i, nplanes = it.nplanes, depth = a.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = a.depth();
|
||||
size_t startidx = 1, idx = 0;
|
||||
int imin = 0, imax = 0;
|
||||
|
||||
@ -1874,7 +1882,8 @@ int cmpEps( const Mat& arr, const Mat& refarr, double* _realmaxdiff,
|
||||
Mat planes[2];
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total()*planes[0].channels(), j = total;
|
||||
int i, nplanes = it.nplanes, depth = arr.depth();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = arr.depth();
|
||||
size_t startidx = 1, idx = 0;
|
||||
double realmaxdiff = 0, maxval = 0;
|
||||
|
||||
@ -2160,11 +2169,11 @@ void gemm( const Mat& _a, const Mat& _b, double alpha,
|
||||
if( a.depth() == CV_32F )
|
||||
GEMM_(a.ptr<float>(), a_step, a_delta, b.ptr<float>(), b_step, b_delta,
|
||||
!c.empty() ? c.ptr<float>() : 0, c_step, c_delta, d.ptr<float>(),
|
||||
d.step1(), a_rows, b_cols, a_cols, cn, alpha, beta );
|
||||
(int)d.step1(), a_rows, b_cols, a_cols, cn, alpha, beta );
|
||||
else
|
||||
GEMM_(a.ptr<double>(), a_step, a_delta, b.ptr<double>(), b_step, b_delta,
|
||||
!c.empty() ? c.ptr<double>() : 0, c_step, c_delta, d.ptr<double>(),
|
||||
d.step1(), a_rows, b_cols, a_cols, cn, alpha, beta );
|
||||
(int)d.step1(), a_rows, b_cols, a_cols, cn, alpha, beta );
|
||||
}
|
||||
|
||||
|
||||
@ -2282,7 +2291,7 @@ void transform( const Mat& src, Mat& dst, const Mat& transmat, const Mat& _shift
|
||||
Mat planes[2];
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total();
|
||||
int i, nplanes = it.nplanes;
|
||||
size_t i, nplanes = it.nplanes;
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -2338,7 +2347,7 @@ static void minmax(const Mat& src1, const Mat& src2, Mat& dst, char op)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total()*planes[0].channels();
|
||||
int i, nplanes = it.nplanes, depth = src1.depth();
|
||||
size_t i, nplanes = it.nplanes, depth = src1.depth();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -2406,7 +2415,7 @@ static void minmax(const Mat& src1, double val, Mat& dst, char op)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total()*planes[0].channels();
|
||||
int i, nplanes = it.nplanes, depth = src1.depth();
|
||||
size_t i, nplanes = it.nplanes, depth = src1.depth();
|
||||
int ival = saturate_cast<int>(val);
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
@ -2478,7 +2487,7 @@ static void muldiv(const Mat& src1, const Mat& src2, Mat& dst, double scale, cha
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[1].total()*planes[1].channels();
|
||||
int i, nplanes = it.nplanes, depth = src2.depth();
|
||||
size_t i, nplanes = it.nplanes, depth = src2.depth();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
@ -2563,7 +2572,8 @@ Scalar mean(const Mat& src, const Mat& mask)
|
||||
|
||||
NAryMatIterator it(arrays, planes);
|
||||
size_t total = planes[0].total();
|
||||
int i, nplanes = it.nplanes, depth = src.depth(), cn = src.channels();
|
||||
size_t i, nplanes = it.nplanes;
|
||||
int depth = src.depth(), cn = src.channels();
|
||||
|
||||
for( i = 0; i < nplanes; i++, ++it )
|
||||
{
|
||||
|
||||
@ -1008,7 +1008,7 @@ ICV_DEF_GET_QUADRANGLE_SUB_PIX_FUNC( 8u32f, uchar, float, double, CV_CAST_32F, C
|
||||
|
||||
CV_IMPL void
|
||||
cvCalcOpticalFlowPyrLK( const void* arrA, const void* arrB,
|
||||
void* pyrarrA, void* pyrarrB,
|
||||
void* /*pyrarrA*/, void* /*pyrarrB*/,
|
||||
const CvPoint2D32f * featuresA,
|
||||
CvPoint2D32f * featuresB,
|
||||
int count, CvSize winSize, int level,
|
||||
|
||||
@ -73,7 +73,7 @@ void CV_AccumBaseTest::get_test_array_types_and_sizes( int test_case_idx,
|
||||
RNG& rng = ts->get_rng();
|
||||
int depth = cvtest::randInt(rng) % 3, cn = cvtest::randInt(rng) & 1 ? 3 : 1;
|
||||
int accdepth = std::max((int)(cvtest::randInt(rng) % 2 + 1), depth);
|
||||
int i, input_count = test_array[INPUT].size();
|
||||
int i, input_count = (int)test_array[INPUT].size();
|
||||
cvtest::ArrayTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
|
||||
depth = depth == 0 ? CV_8U : depth == 1 ? CV_32F : CV_64F;
|
||||
accdepth = accdepth == 1 ? CV_32F : CV_64F;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user