int CRegionEvaluator::Score(ChessType* board, ChessType color, int emptiesNum) const
{
ChessType oppcolor = Oppl_ch(color);
int tmpEval = BorderScore(board, color, oppcolor); //四边
tmpEval += AngleScore(board, color, oppcolor); //四角
tmpEval += CenterScore(board, color, oppcolor); //中心区域
tmpEval += InnerBorderScore(board, color, oppcolor); //中心区域
tmpEval += CountScore(board, color, oppcolor, emptiesNum);
return tmpEval;
}
MatchedBlockPair *FindBestSet (MatchedBlockPair *matches, int numMatches, MultipleAlignment *a1, MultipleAlignment *a2, ScoreData *s) {
Vector min, max = {0.0,0.0,0.0};
MemoryManagementInfo info = {0,0};
MatchedBlockPair **list = (MatchedBlockPair **) malloc(numMatches * sizeof(MatchedBlockPair *));
double displacementRange = s->displacement * 2;
int best = 0;
int i;
int pos;
OctTreeNode *trees = (OctTreeNode *) malloc(a2->numResidues * sizeof(OctTreeNode));
double maxBonus = MAX_BONUS;
double maxPosBonus = MAX_POS_BONUS;
if (!numMatches) return 0;
for (i=0; i<a1->numResidues; i++) {
/* Currently allow missing positions only in single-structure "alignments."
* May allow farther on or remove them altogether. Currently no benefit from
* not just removing residues with no alpha carbon coordinates.
*/
if (a1->numChains > 1 || a1->residues[0].res[i].exists) {
max = a1->averages[i++];
break;
}
}
min = max;
for (; i<a1->numResidues; i++) {
/* Safety check. */
if (a1->numChains == 1 && !a1->residues[0].res[i].exists) continue;
if (a1->averages[i].x < min.x) {
min.x = a1->averages[i].x;
}
else if (a1->averages[i].x > max.x) {
max.x = a1->averages[i].x;
}
if (a1->averages[i].y < min.y) {
min.y = a1->averages[i].y;
}
else if (a1->averages[i].y > max.y) {
max.y = a1->averages[i].y;
}
if (a1->averages[i].z < min.z) {
min.z = a1->averages[i].z;
}
else if (a1->averages[i].z > max.z) {
max.z = a1->averages[i].z;
}
}
for (i=0; i<a2->numResidues; i++) {
InitOctTreeNode(&trees[i], &min, &max);
}
for (i=0; i<numMatches; i++) {
Vector v, first;
MatchedBlockPair *match = &matches[i];
match->bestPreviousMatch = -1;
/* In this case, don't allow it to be added without a previous strand,
* unless it's the first strand.
*/
if (s->firstStrandLocked) {
if (i) {
match->bestAssembledScore = -5000;
}
else {
/* Otherwise, keep previous assembled score. Means I can
* just insert into old alignments without changing scores.
*/
match->bestAssembledScore -= match->score;
}
}
else
match->bestAssembledScore = 0;
transformVect(&first, &match->m, &a2->averages[match->p2]);
for (pos=4; pos<match->p2; pos++) {
int hits, j;
transformVect(&v, &match->m, &a2->averages[pos]);
hits = GetEntries((void**)list, &trees[pos], &v, displacementRange);
for (j=0; j < hits; j++) {
Vector v1, v2;
MatchedBlockPair *match2 = list[j];
double score, invCosHalfTest, angle, displacement;
if (match2->p1 + match2->len > match->p1) {
continue;
}
if (match2->p2 + match2->len > a2->conflictMap[match->p2][0]) {
if (match2->p2 + match2->len-1 == a2->conflictMap[match->p2][0] ||
a2->conflictMap[match->p2][match2->p2 + match2->len-1 - a2->conflictMap[match->p2][0]])
continue;
}
if (match2->p1 + match2->len > a1->conflictMap[match->p1][0]) {
if (match2->p1 + match2->len-1 == a1->conflictMap[match->p1][0] ||
a1->conflictMap[match->p1][match2->p1 + match2->len-1 - a1->conflictMap[match->p1][0]])
continue;
}
score = match2->bestAssembledScore;
if (score + maxBonus < match->bestAssembledScore) continue;
invCosHalfTest = invHalfCosQuat(&match->q, &match2->q);
if (invCosHalfTest < s->angleCos) continue;
angle = 0;
if (invCosHalfTest<1) angle = 2*acos(invCosHalfTest);
score += AngleScore(angle);
if (score + maxPosBonus < match->bestAssembledScore) continue;
subVect(&v1, &match2->last, &v);
transformVect(&v2, &match2->m, &a2->averages[match->p2]);
subVect(&v2, &first, &v2);
displacement = (lengthVect(&v1) + lengthVect(&v2))/2;
if (displacement > s->displacement) continue;
score += DisplacementScore(displacement);
if (score < match->bestAssembledScore) continue;
match->bestAssembledScore = (float) score;
match->bestPreviousMatch = (int)(match2 - matches);
}
}
if (match->bestAssembledScore < 0) continue;
match->bestAssembledScore += match->score;
if (match->bestAssembledScore > matches[best].bestAssembledScore)
best = i;
pos = match->p2 + match->len-1;
AddEntry(&trees[pos], &match->last, &info);
}
FreeAllMemory(&info);
free(trees);
free(list);
if (!s->lastStrandLocked)
return &matches[best];
else
return &matches[numMatches-1];
}
