自学教程：C++ Classify函数代码示例

RTREE_TEMPLATEvoid RTREE_QUAL::PickSeeds(PartitionVars* a_parVars) {    int seed0, seed1;    ELEMTYPEREAL worst, waste;    ELEMTYPEREAL area[MAXNODES + 1];    for (int index = 0; index < a_parVars->m_total; ++index) {        area[index] = CalcRectVolume(&a_parVars->m_branchBuf[index].m_rect);    }    worst = -a_parVars->m_coverSplitArea - 1;    for (int indexA = 0; indexA < a_parVars->m_total - 1; ++indexA) {        for (int indexB = indexA + 1; indexB < a_parVars->m_total; ++indexB) {            Rect oneRect = CombineRect(&a_parVars->m_branchBuf[indexA].m_rect, &a_parVars->m_branchBuf[indexB].m_rect);            waste = CalcRectVolume(&oneRect) - area[indexA] - area[indexB];            if (waste > worst) {                worst = waste;                seed0 = indexA;                seed1 = indexB;            }        }    }    Classify(seed0, 0, a_parVars);    Classify(seed1, 1, a_parVars);}

RTREE_TEMPLATEvoid RTREE_QUAL::ChoosePartition(PartitionVars* a_parVars, int a_minFill) {    ASSERT(a_parVars);    ELEMTYPEREAL biggestDiff;    int group, chosen, betterGroup;    InitParVars(a_parVars, a_parVars->m_branchCount, a_minFill);    PickSeeds(a_parVars);    while (((a_parVars->m_count[0] + a_parVars->m_count[1]) < a_parVars->m_total)            && (a_parVars->m_count[0] < (a_parVars->m_total - a_parVars->m_minFill))            && (a_parVars->m_count[1] < (a_parVars->m_total - a_parVars->m_minFill))) {        biggestDiff = (ELEMTYPEREAL) - 1;        for (int index = 0; index < a_parVars->m_total; ++index) {            if (PartitionVars::NOT_TAKEN == a_parVars->m_partition[index]) {                Rect* curRect = &a_parVars->m_branchBuf[index].m_rect;                Rect rect0 = CombineRect(curRect, &a_parVars->m_cover[0]);                Rect rect1 = CombineRect(curRect, &a_parVars->m_cover[1]);                ELEMTYPEREAL growth0 = CalcRectVolume(&rect0) - a_parVars->m_area[0];                ELEMTYPEREAL growth1 = CalcRectVolume(&rect1) - a_parVars->m_area[1];                ELEMTYPEREAL diff = growth1 - growth0;                if (diff >= 0) {                    group = 0;                } else {                    group = 1;                    diff = -diff;                }                if (diff > biggestDiff) {                    biggestDiff = diff;                    chosen = index;                    betterGroup = group;                } else if ((diff == biggestDiff) && (a_parVars->m_count[group] < a_parVars->m_count[betterGroup])) {                    chosen = index;                    betterGroup = group;                }            }        }        Classify(chosen, betterGroup, a_parVars);    }    // If one group too full, put remaining rects in the other    if ((a_parVars->m_count[0] + a_parVars->m_count[1]) < a_parVars->m_total) {        if (a_parVars->m_count[0] >= a_parVars->m_total - a_parVars->m_minFill) {            group = 1;        } else {            group = 0;        }        for (int index = 0; index < a_parVars->m_total; ++index) {            if (PartitionVars::NOT_TAKEN == a_parVars->m_partition[index]) {                Classify(index, group, a_parVars);            }        }    }    ASSERT((a_parVars->m_count[0] + a_parVars->m_count[1]) == a_parVars->m_total);    ASSERT((a_parVars->m_count[0] >= a_parVars->m_minFill) &&            (a_parVars->m_count[1] >= a_parVars->m_minFill));}

//----------------------------------------------------------------------------void BspTree2::GetPartition (const BspPolygon2& polygon, const Vector2d& v0,    const Vector2d& v1, BspPolygon2& pos, BspPolygon2& neg,    BspPolygon2& coSame, BspPolygon2& coDiff) const{    // Construct splitting line from first coincident edge.    Vector2d end0 = polygon.mVArray[mCoincident[0].I0];    Vector2d end1 = polygon.mVArray[mCoincident[0].I1];    Vector2d intr;    switch (Classify(end0, end1, v0, v1, intr))    {    case TRANSVERSE_POSITIVE:        GetPosPartition(polygon, intr, v1, pos, neg, coSame, coDiff);        GetNegPartition(polygon, v0, intr, pos, neg, coSame, coDiff);        break;    case TRANSVERSE_NEGATIVE:        GetPosPartition(polygon, v0, intr, pos, neg, coSame, coDiff);        GetNegPartition(polygon, intr, v1, pos, neg, coSame, coDiff);        break;    case ALL_POSITIVE:        GetPosPartition(polygon, v0, v1, pos, neg, coSame, coDiff);        break;    case ALL_NEGATIVE:        GetNegPartition(polygon, v0, v1, pos, neg, coSame, coDiff);        break;    default:  // COINCIDENT        GetCoPartition(polygon, v0, v1, pos, neg, coSame, coDiff);        break;    }}

Permonkey::Permonkey(float x, float y, Point lTile, TileMap tileMap, unordered_map<string, vector<string>> objList) : character("img/permacaco_anim_ss.png", 4, -1, 4), tileMap(tileMap),step("music/passo_et_verde.wav") {    box = Rect(x-character.GetWidth()/2,y-character.GetHeight(), character.GetWidth(), character.GetHeight());	rotation = 0;	roomID = 0;	crt = 0;	objective.x = 994;	objective.y = 470;	tile = lTile;	actionCharacter = RESTING;	choice = NO_CHOICE;	timer.Restart();	rest.Restart();	hunger = rand()%21;	money = rand()%900+101;	found = true;	satisfaction = 50;	preference = "Pirate";	roomChoice = "";	actualGoal = 0;	Classify(objList);	gone = false;		objectSelect = -1;		}

bool IntrLine2Segment2<Real>::Find (){    Vector2<Real> kDiff;    Real afParameter[2];    m_iIntersectionType = Classify(afParameter,&kDiff,0);    if (m_iIntersectionType == IT_POINT)    {        // Test whether the line-line intersection is on the segment.        if (Math<Real>::FAbs(afParameter[1]) <= m_pkSegment->Extent)        {            m_iQuantity = 1;            m_kPoint = m_pkLine->Origin + afParameter[0]*m_pkLine->Direction;        }        else        {            m_iQuantity = 0;            m_iIntersectionType = IT_EMPTY;        }    }    else if (m_iIntersectionType == IT_SEGMENT)    {        m_iQuantity = INT_MAX;    }    else    {        m_iQuantity = 0;    }    return m_iIntersectionType != IT_EMPTY;}

bool IntrLine2Ray2<Real>::Find (){    Vector2<Real> diff;    Real parameter[2];    mIntersectionType = Classify(parameter, &diff, 0);    if (mIntersectionType == IT_POINT)    {        // Test whether the line-line intersection is on the ray.        if (parameter[1] >= (Real)0)        {            mQuantity = 1;            mPoint = mLine->Origin + parameter[0]*mLine->Direction;        }        else        {            mQuantity = 0;            mIntersectionType = IT_EMPTY;        }    }    else if (mIntersectionType == IT_RAY)    {        mQuantity = INT_MAX;    }    else    {        mQuantity = 0;    }    return mIntersectionType != IT_EMPTY;}

// Classify polygon with respect to this planeint RebPlane::Classify(const RebPolygon &Poly) {   int NumFront=0, NumBack=0, NumPlanar=0;   int nClass;   // cast away const   RebPolygon *pPoly = ((RebPolygon*)&Poly);   int NumPoints = pPoly->GetNumPoints();   // loop through all points   for (int i=0; i < NumPoints; i++) {      nClass = Classify( pPoly->m_pPoints[i] );            if (nClass == RebFRONT)     NumFront++;      else if (nClass == RebBACK) NumBack++;      else {         NumFront++;         NumBack++;         NumPlanar++;         }      } // for      // all points are planar   if (NumPlanar == NumPoints)      return RebPLANAR;   // all points are in front of plane   else if (NumFront == NumPoints)      return RebFRONT;   // all points are on backside of plane   else if (NumBack == NumPoints)      return RebBACK;   // poly is intersecting the plane   else      return RebCLIPPED;   } // Classify

bool IntrSegment2Segment2<Real>::Find (){    Vector2<Real> diff;    Real parameter[2];    mIntersectionType = Classify(parameter, &diff, 0);    if (mIntersectionType == IT_POINT)    {        // Test whether the line-line intersection is on the segments.        if (Math<Real>::FAbs(parameter[0]) <= mSegment0->Extent        &&  Math<Real>::FAbs(parameter[1]) <= mSegment1->Extent)        {            mQuantity = 1;            mPoint = mSegment0->Center + parameter[0]*mSegment0->Direction;        }        else        {            mQuantity = 0;            mIntersectionType = IT_EMPTY;        }    }    else if (mIntersectionType == IT_SEGMENT)    {        mQuantity = INT_MAX;    }    else    {        mQuantity = 0;    }    return mIntersectionType != IT_EMPTY;}

ICopyFilterOption::EResultCRemovePathsBySubString::ShallRemove (const CFullGraphNode* node) const{    // short-cut    if (filterPaths.empty())        return ICopyFilterOption::KEEP_NODE;    // path to classify    const CDictionaryBasedTempPath& path = node->GetPath();    // most paths can be filtered quickly using the classification cache    PathClassification classification = QuickClassification (path.GetBasePath());    // take a closer look if necessary    if ((classification != REMOVE) && !path.IsFullyCachedPath())        classification = Classify (path.GetPath());    // return the result    return classification == REMOVE        ? removeSubTrees ? ICopyFilterOption::REMOVE_SUBTREE                         : ICopyFilterOption::REMOVE_NODE        : ICopyFilterOption::KEEP_NODE;}

bool IntrRay2Segment2<Real>::Find (){    Vector2<Real> diff;    Real parameter[2];    mIntersectionType = Classify(parameter, &diff, 0);    if (mIntersectionType == IT_POINT)    {        // Test whether the line-line intersection is on the ray and on the        // segment.        if (parameter[0] >= (Real)0        &&  Math<Real>::FAbs(parameter[1]) <= mSegment->Extent)        {            mQuantity = 1;            mPoint = mRay->Origin + parameter[0]*mRay->Direction;        }        else        {            mQuantity = 0;            mIntersectionType = IT_EMPTY;        }    }    else if (mIntersectionType == IT_SEGMENT)    {        mQuantity = INT_MAX;    }    else    {        mQuantity = 0;    }    return mIntersectionType != IT_EMPTY;}

bool IntrLine2Segment2<Real>::Test (){    Vector2<Real> diff;    Real parameter[2];    mIntersectionType = Classify(parameter, &diff, 0);    if (mIntersectionType == IT_POINT)    {        // Test whether the line-line intersection is on the segment.        if (Math<Real>::FAbs(parameter[1]) <= mSegment->Extent)        {            mQuantity = 1;        }        else        {            mQuantity = 0;            mIntersectionType = IT_EMPTY;        }    }    else if (mIntersectionType == IT_SEGMENT)    {        mQuantity = INT_MAX;    }    else    {        mQuantity = 0;    }    return mIntersectionType != IT_EMPTY;}

int Classify(Image* img) {	int sum = 0;	for (int i = 0 ; i < featureSize ; i++) {		sum += Classify(img, i);	}	return sum >= 0 ? 1 : -1;}

//LRC - work out gibs from blood colour, instead.BOOL CBaseMonster :: HasAlienGibs( void ){	int myClass = Classify();	// these types of monster don't use gibs	if ( myClass == CLASS_NONE || myClass == CLASS_MACHINE ||		 myClass == CLASS_PLAYER_BIOWEAPON && myClass == CLASS_ALIEN_BIOWEAPON)	{		return FALSE;	}	else	{		return (this->m_bloodColor == BLOOD_COLOR_GREEN);	}//	int myClass = Classify();////	if ( myClass == CLASS_ALIEN_MILITARY ||//		 myClass == CLASS_ALIEN_MONSTER	||//		 myClass == CLASS_ALIEN_PASSIVE  ||//		 myClass == CLASS_INSECT  ||//		 myClass == CLASS_ALIEN_PREDATOR  ||//		 myClass == CLASS_ALIEN_PREY )////		 return TRUE;////	return FALSE;}

void Train(perceptron_t *p, int *inputs, int classification){	int error = classification - Classify(p, inputs);	for (int i = 0; i < 2; i++)	{		p->weights[i] += p->learningRate * (float) error * *(inputs + i);	}}

int LearnCV(TMatrix input,  TVariables output, unsigned int minFeatures, unsigned int upToPower, unsigned int folds, TPoint *ray, unsigned int *power){	bool oldOUT_ALPHA = OUT_ALPHA;	OUT_ALPHA = false;	unsigned int optDegree = 0;	unsigned int optError = INT_MAX;	unsigned int shortFolds = folds - 1;	/* Get the optimal degree (outer cross-validation loop) */	vector<TMatrix> spaceExtensions(upToPower);	for (unsigned int i = 0; i < upToPower; i++){		ExtendWithProducts(input, i + 1, &spaceExtensions[i]); // get the (i + 1)-th space extention		Initialization(spaceExtensions[i], output, minFeatures); // initialize		/* Prepare slider and start to cut data */		unsigned sliderSize = (unsigned)ceil((double)n / folds); unsigned chSizeVal = n%folds - 1;		TMatrix xSlider(sliderSize); TVariables ySlider(sliderSize);		for (unsigned int j = 0; j < sliderSize; j++){			xSlider[j] = TPoint(d);			for (unsigned int k = 0; k < d; k++){xSlider[j][k] = x[k][j*shortFolds]; x[k].erase(x[k].begin() + j*shortFolds);}			ySlider[j] = y[j*shortFolds]; y.erase(y.begin() + j*shortFolds);			difference -= ySlider[j]; if (ySlider[j] > 0){numMore--;}else{numLess--;}					}		n -= sliderSize;		/* Cross-validation for the (i + 1)-th space extension (inner cross-validation loop) */		unsigned int error = 0; TPoint p(0);		double tmpXSliderVal; int tmpYSliderVal;		for (unsigned int j = 0; j < folds; j++){			/* Estimate the current cut */						Alpha(&p);			TVariables res(0);			Classify(xSlider, p, &res);			for (unsigned int k = 0; k < sliderSize; k++){error += abs(res[k] - ySlider[k])/2;}			/* Increment the pointer */			if (j == shortFolds){break;}			/* Replace the slider */			if (j == chSizeVal){				for (unsigned int l = 0; l < d; l++){x[l].push_back(xSlider[sliderSize - 1][l]);} y.push_back(ySlider[sliderSize - 1]);				n++; difference += ySlider[sliderSize - 1]; if (ySlider[sliderSize - 1] > 0){numMore++;}else{numLess++;}				sliderSize--; xSlider.erase(xSlider.begin() + sliderSize); ySlider.erase(ySlider.begin() + sliderSize);//				for (unsigned int j = 0; j < d; j++){x[j].shrink_to_fit();} y.shrink_to_fit(); - IT IS TOO DANGEROUS			}			for (unsigned int k = 0; k < sliderSize; k++){				for (unsigned int l = 0; l < d; l++){tmpXSliderVal = x[l][k*shortFolds + j]; x[l][k*shortFolds + j] = xSlider[k][l]; xSlider[k][l] = tmpXSliderVal;}				difference += ySlider[k]; if (ySlider[k] > 0){numMore++;}else{numLess++;}				tmpYSliderVal = y[k*shortFolds + j]; y[k*shortFolds + j] = ySlider[k]; ySlider[k] = tmpYSliderVal;				difference -= ySlider[k]; if (ySlider[k] > 0){numMore--;}else{numLess--;}			}		}		/* Check if we've got a better result */ 		if (error < optError){optError = error; optDegree = i + 1; if (optError == 0){break;}}	}	OUT_ALPHA = oldOUT_ALPHA;	/* Eventually get the classification ray */	Initialization(spaceExtensions[optDegree - 1], output, minFeatures); // initialize	power[0] = optDegree;	return Alpha(ray);}

void ResetBDAC(void)	{	int dummy ;	QRSDet(0,1) ;	// Reset the qrs detector	RRCount = 0 ;	Classify(BeatBuffer,0,0,&dummy,&dummy,1) ;	InitBeatFlag = 1 ;   BeatQueCount = 0 ;	// Flush the beat que.	}

void DouglasPeuckerMod::Encode(std::vector<IGCFixEnhanced> &fixes,                                             const unsigned start, const unsigned end) {  unsigned max_loc = 0;  std::stack<std::pair<unsigned, unsigned>> stack;  const unsigned fixes_size = end - start;  DistQueue dists;  double temp,         max_dist,         abs_max_dist_squared = 0.0,         abs_max_dist,         threshold_squared = pow(threshold, 2);  /**   * use normal douglas peucker distance (perpendicular to segment) for lon/lat   * and use simple distance calculation for time   */  // simplify using Douglas-Peucker  if (fixes_size > 2) {    stack.push(std::pair<unsigned, unsigned>(start, end - 1));    while (stack.size() > 0) {      std::pair<unsigned, unsigned> current = stack.top();      stack.pop();      max_dist = 0;      for (unsigned i = current.first + 1; i < current.second; i++) {        temp = std::max(DistanceGeo(fixes[i].location,                                    fixes[current.first].location,                                    fixes[current.second].location),                        DistanceTime(fixes[i].clock,                                     fixes[current.first].clock,                                     fixes[current.second].clock));        if (temp > max_dist) {          max_dist = temp;          max_loc = i;        }      }      if (max_dist > abs_max_dist_squared) {        abs_max_dist_squared = max_dist;      }      if (max_dist > threshold_squared) {        dists.push(std::pair<unsigned, double>(max_loc, sqrt(max_dist)));        stack.push(std::pair<unsigned, unsigned>(current.first, max_loc));        stack.push(std::pair<unsigned, unsigned>(max_loc, current.second));      }    }  }  abs_max_dist = sqrt(abs_max_dist_squared);  Classify(fixes, dists, abs_max_dist, start, end);}

void Train(int index) {	w1[index] = 1;	w2[index] = 0;	for (int i = 0 ; i < negCount + posCount ; i++) {		int choice = i; //No longer random		Image* img = GetTrainAt(choice);		int x = img->FeatureAt(index);		int h = Classify(img, index);		w1[index] -= epsilon * (h - img->Type()) * x;		w2[index] -= epsilon * (h - img->Type());	}}

BOOL CBaseMonster::__MAKE_VHOOK(HasHumanGibs)(){	int myClass = Classify();	if (myClass == CLASS_HUMAN_MILITARY		|| myClass == CLASS_PLAYER_ALLY		|| myClass == CLASS_HUMAN_PASSIVE		|| myClass == CLASS_PLAYER)		 return TRUE;	return FALSE;}

double Test(const CvSVM &svm, const cv::Mat &features, const cv::Mat &targets) {  double error = 0;  for(size_t rowIndex = 0; rowIndex < features.rows; ++rowIndex) {    const int *target = targets.ptr<int>(rowIndex);    int predictedTarget = Classify(svm, features.row(rowIndex));    if(predictedTarget != target[0]) {      error++;    }    // std::cout << predictedTarget << ' ' << target[0] << std::endl;  }  return error / features.rows;  // std::cout << std::endl;}

bool CHL1BaseNPC::HasHumanGibs( void ){	Class_T myClass = Classify();	if ( myClass == CLASS_HUMAN_MILITARY ||		 myClass == CLASS_PLAYER_ALLY	||		 myClass == CLASS_HUMAN_PASSIVE  ||		 myClass == CLASS_PLAYER )		 return true;	return false;}

bool Perceptron::Train(const std::vector<double>& input, const int& output)   // return whether theta has been changed{	//std::cout << Classify(input) << output << std::endl;	if( Classify(input) != output ) {		for( size_t i = 0; i < _insize; ++i ) {			//std::cout << "theta " << i << " = " << _theta[i] << std::endl;			//std::cout << "Delta theta " << i << " = " << input[i]*output << std::endl;			_theta[i] += input[i]*output;			//std::cout << "theta " << i << " = " << _theta[i] << std::endl;		}		return true;	}	return false;}

//-----------------------------------------------------------------------------// Purpose: LeapTouch - this is the headcrab's touch function when it is in the air.// Input  : *pOther - //-----------------------------------------------------------------------------void CNPC_Headcrab::LeapTouch( CBaseEntity *pOther ){	if ( pOther->Classify() == Classify() )	{		return;	}	// Don't hit if back on ground	if ( !(GetFlags() & FL_ONGROUND) )	{		BiteSound();		TouchDamage( pOther );	}	SetTouch( NULL );}

PRUint32nsHttpPipeline::CancelPipeline(nsresult originalReason){    PRUint32 i, reqLen, respLen, total;    nsAHttpTransaction *trans;    reqLen = mRequestQ.Length();    respLen = mResponseQ.Length();    total = reqLen + respLen;    // don't count the first response, if presnet    if (respLen)        total--;    if (!total)        return 0;    // any pending requests can ignore this error and be restarted    // unless it is during a CONNECT tunnel request    for (i = 0; i < reqLen; ++i) {        trans = Request(i);        if (mConnection && mConnection->IsProxyConnectInProgress())            trans->Close(originalReason);        else            trans->Close(NS_ERROR_NET_RESET);        NS_RELEASE(trans);    }    mRequestQ.Clear();    // any pending responses can be restarted except for the first one,    // that we might want to finish on this pipeline or cancel individually.    // Higher levels of callers ensure that we don't process non-idempotent    // tranasction with the NS_HTTP_ALLOW_PIPELINING bit set    for (i = 1; i < respLen; ++i) {        trans = Response(i);        trans->Close(NS_ERROR_NET_RESET);        NS_RELEASE(trans);    }    if (respLen > 1)        mResponseQ.TruncateLength(1);    DontReuse();    Classify(nsAHttpTransaction::CLASS_SOLO);    return total;}

// Classifyint imageNet::Classify( float* rgba, uint32_t width, uint32_t height, float* confidence ){	// verify parameters	if( !rgba || width == 0 || height == 0 )	{		printf(LOG_TRT "imageNet::Classify( 0x%p, %u, %u ) -> invalid parameters/n", rgba, width, height);		return -1;	}		// downsample and convert to band-sequential BGR	if( !PreProcess(rgba, width, height) )	{		printf(LOG_TRT "imageNet::Classify() -- PreProcess() failed/n");		return -1;	}		return Classify(confidence);}

//-----------------------------------------------------------------------------// Purpose: // Output : Returns true on success, false on failure.//-----------------------------------------------------------------------------bool CNPCSimpleTalker::CanSayHello( void ){#ifndef HL1_DLL	if ( Classify() == CLASS_PLAYER_ALLY_VITAL )		return false;#endif		if ( GetSpeechFilter() && GetSpeechFilter()->NeverSayHello() )		return false;	if ( !GetExpresser()->CanSpeakConcept(TLK_HELLO) || GetExpresser()->SpokeConcept(TLK_HELLO) )		return false;	if ( !IsOkToSpeak() )		return false;	return true;}