RTREE_TEMPLATE
void 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_TEMPLATE
void 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;
}
Permonkey::Permonkey(ifstream &file, TileMap tileMap, unordered_map<string, vector<string>> objList) :
character("img/permacaco_anim_ss.png", 4, -1, 4), tileMap(tileMap) {
file.read(reinterpret_cast<char*> (&box), sizeof(Rect));
file.read(reinterpret_cast<char*> (&rotation), sizeof(float));
file.read(reinterpret_cast<char*> (&roomID), sizeof(int));
file.read(reinterpret_cast<char*> (&crt), sizeof(int));
file.read(reinterpret_cast<char*> (&objective), sizeof(Point));
file.read(reinterpret_cast<char*> (&tile), sizeof(Point));
file.read(reinterpret_cast<char*> (&actionCharacter), sizeof(ActionCharacter));
file.read(reinterpret_cast<char*> (&choice), sizeof(Choice));
file.read(reinterpret_cast<char*> (&hunger), sizeof(int));
file.read(reinterpret_cast<char*> (&money), sizeof(int));
file.read(reinterpret_cast<char*> (&found), sizeof(bool));
file.read(reinterpret_cast<char*> (&satisfaction), sizeof(int));
file.read(reinterpret_cast<char*> (&actualGoal), sizeof(int));
file.read(reinterpret_cast<char*> (&objectSelect), sizeof(int));
int size;
file.read(reinterpret_cast<char*> (&size), sizeof(int));
preference.resize(size);
for (int p = 0; p < preference.size(); p++){
file.read(reinterpret_cast<char*> (&preference[p]), sizeof(char));
}
file.read(reinterpret_cast<char*> (&size), sizeof(int));
roomChoice.resize(size);
for (int p = 0; p < roomChoice.size(); p++){
file.read(reinterpret_cast<char*> (&roomChoice[p]), sizeof(char));
}
file.read(reinterpret_cast<char*> (&timer), sizeof(Timer));
file.read(reinterpret_cast<char*> (&rest), sizeof(Timer));
Classify(objList);
}
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 plane
int 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
//----------------------------------------------------------------------------
int BspTree2::PointLocation (const BspPolygon2& polygon,
const Vector2d& vertex) const
{
// Construct splitting line from first coincident edge.
Vector2d end0 = polygon.mVArray[mCoincident[0].I0];
Vector2d end1 = polygon.mVArray[mCoincident[0].I1];
switch (Classify(end0, end1, vertex))
{
case ALL_POSITIVE:
if (mPosChild)
{
return mPosChild->PointLocation(polygon, vertex);
}
else
{
return 1;
}
case ALL_NEGATIVE:
if (mNegChild)
{
return mNegChild->PointLocation(polygon, vertex);
}
else
{
return -1;
}
default: // COINCIDENT
return CoPointLocation(polygon, vertex);
}
}
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::EResult
CRemovePathsBySubString::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 CBaseMonster::__MAKE_VHOOK(HasAlienGibs)()
{
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;
}
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;
}
bool CHL1BaseNPC::HasAlienGibs( void )
{
Class_T myClass = Classify();
if ( myClass == CLASS_ALIEN_MILITARY ||
myClass == CLASS_ALIEN_MONSTER ||
myClass == CLASS_INSECT ||
myClass == CLASS_ALIEN_PREDATOR ||
myClass == CLASS_ALIEN_PREY )
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 );
}
PRUint32
nsHttpPipeline::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;
}
// Classify
int 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;
}
