void SweepAndPrune::swapEndPoints(unsigned int axis, unsigned int a, unsigned int b) {
auto axisvec = _axis[axis];
EndPoint temp = axisvec->at(a);
axisvec->at(a) = axisvec->at(b);
axisvec->at(b) = temp;
EndPoint& aend = axisvec->at(b);
EndPoint& bend = axisvec->at(a);
auto amax = isMax(aend.box);
auto bmax = isMax(bend.box);
auto aidx = boxIndex(aend.box);
auto bidx = boxIndex(bend.box);
auto& abox = _objects[aidx];
auto& bbox = _objects[bidx];
if (amax)
abox.max[axis] = b;
else
abox.min[axis] = b;
if (bmax)
bbox.max[axis] = a;
else
bbox.min[axis] = a;
}
void HessianDetector::findLevelKeypoints(float curScale, float pixelDistance)
{
assert(par.border >= 2);
const int rows = cur.rows;
const int cols = cur.cols;
for (int r = par.border; r < (rows - par.border); r++)
{
for (int c = par.border; c < (cols - par.border); c++)
{
const float val = cur.at<float>(r,c);
if ( (val > positiveThreshold && (isMax(val, cur, r, c) && isMax(val, low, r, c) && isMax(val, high, r, c))) ||
(val < negativeThreshold && (isMin(val, cur, r, c) && isMin(val, low, r, c) && isMin(val, high, r, c))) )
// either positive -> local max. or negative -> local min.
localizeKeypoint(r, c, curScale, pixelDistance);
}
}
}
// Delete list.
void
SkFontDataList::release()
{
if( isMax() )
{
resetFonts();
free( mFonts );
mFonts = NULL;
}
}
void SweepAndPrune::fixRefs(unsigned int axis, unsigned int start) {
auto axisvec = _axis[axis];
for (unsigned int i = start; i < axisvec->size() - 1; ++i) {
unsigned int boxIdx = boxIndex(axisvec->at(i).box);
bool max = isMax(axisvec->at(i).box);
if (max)
_objects[boxIdx].max[axis] = i;
else
_objects[boxIdx].min[axis] = i;
}
}
// Clear list.
void
SkFontDataList::resetFonts()
{
if( isMax() )
{
for( uint32_t n = 0 ; n < mNumFonts ; n++ )
{
if( mFonts[n] )
{
SkDELETE( mFonts[n] );
mFonts[n] = NULL;
}
}
mNumFonts = 0;
}
}
void LinearProblem::RemoveRow(int row) {
static int indices[MAX_VARS];
static double values[MAX_VARS];
int nonZeros = glp_get_mat_row(lp_, row, indices, values);
glp_set_row_bnds(lp_, row, GLP_FR, 0.0, 0.0);
// glpk ignores the 0's index of the array
int ind[2];
double val[2];
for (int i = 1; i <= nonZeros; ++i) {
ind[1] = indices[i];
val[1] = (isMax(colToVar_[indices[i]]) ? -1 : 1);
int r = glp_add_rows(lp_, 1);
glp_set_row_bnds(lp_, r, GLP_UP, 0.0, MINUS_INFTY);
glp_set_mat_row(lp_, r, 1, ind, val);
}
}
int main(int argc, const char * argv[]) {
int num[] = {34,56,67,23,567,67,98,87};
int len = sizeof(num) / sizeof(num[0]);
//最大值
int res = isMax(num,len);
printf("%d \n",res);
//最小值
res = isMin(num,len);
printf("%d \n",res);
//累加和
res = sum(num,len);
printf("%d \n",res);
//平均数
res = avg(num,len);
printf("%d \n",res);
//找
int key = 23;
res = number(num,len,key);
printf("%d \n",res);
}
bool Normalization::algorithm() {
KstVectorPtr vectorIn = inputVector(VECTOR_IN);
KstVectorPtr vectorOut = outputVector(VECTOR_OUT);
double *arr;
double *Yi;
int iLength = vectorIn->length();
int w = 1;
arr = new double[iLength];
Yi = new double[iLength];
for(int i=0; i<iLength; i++)
{
Yi[i] = vectorIn->value()[i];
}
//
// exclude peak values
//
for(int loop=0; loop<2; loop++)
{
for(int i=0; i<iLength; i++)
{
arr[i] = Yi[i];
}
for(int i=0; i<iLength; i++)
{
if(isMin(Yi, i, iLength) || isMax(Yi, i, iLength))
{
excludePts(arr, i, w, iLength);
}
}
searchHighPts(arr, iLength);
interpolate(Yi, arr, iLength);
}
//
// do a piecewise linear fit
//
vectorOut->resize(iLength, false);
int L = 3;
double cof[2] = { 0.0, 0.0 };
for(int i=0; i<iLength; i=i+L)
{
fit(i, L, iLength, Yi, cof, vectorOut);
}
//
// normalize
//
for(int i=0; i<iLength; i++)
{
vectorOut->value()[i] = vectorIn->value()[i] / vectorOut->value()[i];
}
//
// exclude off points
//
for(int i=0; i<iLength; i++)
{
if(vectorOut->value()[i] < 0.0 || vectorOut->value()[i] > 1.2)
{
vectorOut->value()[i] = NOPOINT;
}
}
delete[] arr;
delete[] Yi;
return true;
}
