TEST_F(MatcherGTest, testPgaMatching) {
count n = 50;
Graph G(n);
G.forNodePairs([&](node u, node v){
G.addEdge(u,v);
});
PathGrowingMatcher pgaMatcher(G);
DEBUG("Start PGA matching on 50-clique");
pgaMatcher.run();
Matching M = pgaMatcher.getMatching();
count numExpEdges = n / 2;
bool isProper = M.isProper(G);
EXPECT_TRUE(isProper);
EXPECT_EQ(M.size(G), numExpEdges);
DEBUG("Finished PGA matching on 50-clique");
#if !defined _WIN32 && !defined _WIN64 && !defined WIN32 && !defined WIN64
DibapGraphReader reader;
Graph airfoil1 = reader.read("input/airfoil1.gi");
PathGrowingMatcher pga2(airfoil1);
pga2.run();
M = pga2.getMatching();
isProper = M.isProper(airfoil1);
EXPECT_TRUE(isProper);
DEBUG("PGA on airfoil1 produces matching of size: " , M.size(G));
#endif
}
void matchSurf(const Mat_f& kdesc0, const Mat_f& kdesc1, Matching& matches,
float ratio) {
assert(kdesc0.rows > 0);
assert(kdesc0.cols == kdesc1.cols);
int dimDesc = kdesc0.cols;
matches.clear();
matches.reserve(std::max(kdesc0.rows, kdesc1.rows));
float dist, d1, d2;
for (int i = 0; i < kdesc0.rows; i++) {
d1 = d2 = FLT_MAX;
int jMin = -1;
for (int j = 0; j < kdesc1.rows; j++) {
dist = computeSurfDescDist(kdesc0.data + i * dimDesc,
kdesc1.data + j * dimDesc, dimDesc);
if (dist < d1) // if this feature matches better than current best
{
d2 = d1;
d1 = dist;
jMin = j;
} else if (dist < d2) // this feature matches better than second best
{
d2 = dist;
}
}
// If match has a d1:d2 ratio < 0.65 ipoints are a match
if (d1 / d2 < ratio) {
matches.add(i, jMin, d1);
}
}
}
void cvMatch2MyMatch(const DMatchVec& cvMatch , Matching& myMatch) {
int numMatch = cvMatch.size();
myMatch.reserve(numMatch);
for (int i = 0; i < numMatch; i++) {
myMatch.add(cvMatch[i].queryIdx, cvMatch[i].trainIdx, cvMatch[i].distance);
}
}
void matchSurf(int dimDesc, std::vector<float>& desc0,
std::vector<float>& desc1, Matching& matches, float ratio,
float maxDist) {
int len0 = (int) desc0.size();
int len1 = (int) desc1.size();
assert(len0 % dimDesc == 0 && len1 %dimDesc == 0);
int npts0 = len0 / dimDesc;
int npts1 = len1 / dimDesc;
matches.clear();
matches.reserve(npts0 > npts1 ? npts0 : npts1);
float dist, d1, d2;
for (int i = 0; i < npts0; i++) {
d1 = d2 = FLT_MAX;
int jMin = -1;
for (int j = 0; j < npts1; j++) {
dist = computeSurfDescDist(&desc0[0] + i * dimDesc,
&desc1[0] + j * dimDesc, dimDesc);
if (dist < d1) {
d2 = d1;
d1 = dist;
jMin = j;
} else if (dist < d2)
d2 = dist;
}
if (d1 < maxDist && d1 / d2 < ratio) {
matches.add(i, jMin, d1);
}
}
}
Matching GetAlignedMatching(size_t size) {
Matching match;
for (size_t i = 0; i < size; i++) {
match.push_back(DMatch(i, i, 0));
}
return match;
}
void RGFlow<Two_scale>::run_up()
{
VERBOSE_MSG("> running tower up (iteration " << iteration << ") ...");
const size_t number_of_models = models.size();
for (size_t m = 0; m < number_of_models; ++m) {
TModel* model = models[m];
model->model->set_precision(get_precision());
VERBOSE_MSG("> \tselecting model " << model->model->name());
// apply all constraints
const size_t n_upwards_constraints = model->upwards_constraints.size();
for (size_t c = 0; c < n_upwards_constraints; ++c) {
Constraint<Two_scale>* constraint = model->upwards_constraints[c];
const double scale = constraint->get_scale();
VERBOSE_MSG("> \t\tselecting constraint " << c << " at scale " << scale);
VERBOSE_MSG("> \t\t\trunning model to scale " << scale);
if (model->model->run_to(scale))
throw NonPerturbativeRunningError(scale);
VERBOSE_MSG("> \t\t\tapplying constraint");
constraint->apply();
}
// apply matching condition if this is not the last model
if (m != number_of_models - 1) {
VERBOSE_MSG("> \tmatching to model " << models[m + 1]->model->name());
Matching<Two_scale>* mc = model->matching_condition;
mc->match_low_to_high_scale_model();
}
}
VERBOSE_MSG("> running up finished");
}
TEST_F(MatcherGTest, testLocalMaxMatching) {
count n = 50;
Graph G(n);
G.forNodePairs([&](node u, node v){
G.addEdge(u,v);
});
LocalMaxMatcher localMaxMatcher(G);
TRACE("Start localMax matching");
localMaxMatcher.run();
Matching M = localMaxMatcher.getMatching();
TRACE("Finished localMax matching");
count numExpEdges = n / 2;
bool isProper = M.isProper(G);
EXPECT_TRUE(isProper);
EXPECT_EQ(M.size(G), numExpEdges);
#if !defined _WIN32 && !defined _WIN64 && !defined WIN32 && !defined WIN64
DibapGraphReader reader;
Graph airfoil1 = reader.read("input/airfoil1.gi");
LocalMaxMatcher lmm(airfoil1);
lmm.run();
M = lmm.getMatching();
isProper = M.isProper(airfoil1);
EXPECT_TRUE(isProper);
DEBUG("LocalMax on airfoil1 produces matching of size: " , M.size(G));
#endif
}
int RGFlow<Two_scale>::run_to(double scale)
{
// find model which is defined at `scale'
model_at_this_scale = NULL;
const size_t number_of_models = models.size();
for (size_t m = 0; m < models.size(); ++m) {
TModel* model = models[m];
double highest_scale, lowest_scale;
if (!model) {
ERROR("RGFlow<Two_scale>::run_to: pointer to model " << m
<< " is zero");
return 1;
}
if (m != number_of_models - 1) {
// if this is not the last model, the matching condition is
// the highest scale
Matching<Two_scale>* mc = model->matching_condition;
if (!mc) {
ERROR("RGFlow<Two_scale>::run_to: pointer to matching condition"
" of model " << m << " is zero");
return 1;
}
highest_scale = mc->get_scale();
} else {
// otherwise the last constraint is at the highest scale
if (model->upwards_constraints.empty())
highest_scale = std::numeric_limits<double>::max();
else
highest_scale = model->upwards_constraints.back()->get_scale();
}
if (m > 0) {
// if this is not the first model, the previous matching
// condition is the lowest scale
lowest_scale = models[m-1]->matching_condition->get_scale();
} else {
// otherwise the first constraint is at the lowest scale
if (model->upwards_constraints.empty())
lowest_scale = 0.;
else
lowest_scale = model->upwards_constraints[0]->get_scale();
}
if (lowest_scale <= scale && scale <= highest_scale) {
model_at_this_scale = model->model;
break;
}
}
if (model_at_this_scale)
return model_at_this_scale->run_to(scale);
return 1;
}
TEST_F(MatcherGTest, tryValidMatching) {
METISGraphReader reader;
Graph G = reader.read("coAuthorsDBLP.graph");
LocalMaxMatcher pmatcher(G);
pmatcher.run();
Matching M = pmatcher.getMatching();
bool isProper = M.isProper(G);
EXPECT_TRUE(isProper);
}
int refineMatchedPoints(const Mat_d& pts1, const Mat_d& pts2, Matching& matches,
Matching& newMatches, double ratio) {
double ud[2] = { 0, 0 };
Mat_d d(matches.num, 2);
int num = matches.num;
for (int i = 0; i < num; i++) {
int idx1 = matches[i].idx1;
int idx2 = matches[i].idx2;
d.data[2 * i] = pts2.data[2 * idx2] - pts1.data[2 * idx1];
d.data[2 * i + 1] = pts2.data[2 * idx2 + 1] - pts1.data[2 * idx1 + 1];
ud[0] += d.data[2 * i];
ud[1] += d.data[2 * i + 1];
}
ud[0] /= num;
ud[1] /= num;
double cov[4] = { 0, 0, 0, 0 };
for (int i = 0; i < num; i++) {
double dx = d.data[2 * i] - ud[0];
double dy = d.data[2 * i + 1] - ud[1];
cov[0] += dx * dx;
cov[1] += dx * dy;
cov[3] += dy * dy;
}
double s = ratio * ratio;
cov[0] /= num / s;
cov[1] /= num / s;
cov[3] /= num / s;
cov[2] = cov[1];
double icov[4];
mat22Inv(cov, icov);
newMatches.clear();
newMatches.reserve(num);
for (int i = 0; i < num; i++) {
double dx = d.data[2 * i] - ud[0];
double dy = d.data[2 * i + 1] - ud[1];
double dist = dx * dx * icov[0] + 2 * dx * dy * icov[1]
+ dy * dy * icov[2];
if (dist < 1.0) {
newMatches.add(matches[i].idx1, matches[i].idx2, 0);
}
}
return newMatches.num;
}
void verifyMatching(BipartiteGraph g, unsigned expectedSize)
{
Matching matching = findMaximumMatching(g);
typedef boost::unordered_set<unsigned> VertexSet;
VertexSet first;
VertexSet second;
for (auto elem : matching)
{
ASSERT_TRUE(first.insert(elem.first).second);
ASSERT_TRUE(second.insert(elem.second).second);
ASSERT_TRUE(g.edgeExists(elem));
}
ASSERT_EQ(expectedSize, matching.size());
}
void drawMatching(const ImgG& img1, const Mat_d& keyPts1, const ImgG& img2,
const Mat_d& keyPts2, ImgRGB& outImg, double scale,
unsigned char* flag) {
int numPts = keyPts1.rows;
Matching matches;
matches.reserve(numPts);
cv::RNG rng;
for (int i = 0; i < numPts; i++) {
matches.add(i, i, 0);
}
drawMatching(img1, keyPts1, img2, keyPts2, matches, outImg, scale, flag);
}
void GetAlignedPointsFromMatch(const Features& leftFeatures,
const Features& rightFeatures,
const Matching& matches,
Features& alignedLeft,
Features& alignedRight,
vector<int>& leftBackReference,
vector<int>& rightBackReference)
{
alignedLeft .keyPoints.clear();
alignedRight.keyPoints.clear();
alignedLeft .descriptors = cv::Mat();
alignedRight.descriptors = cv::Mat();
for (unsigned int i=0; i<matches.size(); i++) {
alignedLeft .keyPoints .push_back(leftFeatures.keyPoints [matches[i].queryIdx]);
alignedLeft .descriptors.push_back(leftFeatures.descriptors.row (matches[i].queryIdx));
alignedRight.keyPoints .push_back(rightFeatures.keyPoints [matches[i].trainIdx]);
alignedRight.descriptors.push_back(rightFeatures.descriptors.row(matches[i].trainIdx));
leftBackReference .push_back(matches[i].queryIdx);
rightBackReference.push_back(matches[i].trainIdx);
}
KeyPointsToPoints(alignedLeft.keyPoints, alignedLeft.points);
KeyPointsToPoints(alignedRight.keyPoints, alignedRight.points);
}
IDIS() {
fileLeft = "/apps/workspaces/kiste_data/stereo/2/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/2/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(257,369); Point2i pr1(98,367); pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(261,579); Point2i pr2(101,589); pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(282,692); Point2i pr3(121,708); pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(657,673); Point2i pr4(520,678); pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(704,247); Point2i pr5(569,247); pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(816,641); Point2i pr6(679,641); pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(1113,503); Point2i pr7(964,501); pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(1025,472); Point2i pr8(882,472); pr8 = matcher.refine(sad, pl8, pr8);
Point2i pl9(1096,345); Point2i pr9(948,348); pr9 = matcher.refine(sad, pl9, pr9);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
//fm.addCorrespondence(pl9, pr9);
fm.estimate();
}
/** match SURF feature points between two views*/
int NewMapPtsSURF::matchBetween(int iCam, int jCam, Matching& matches) {
std::vector<float>& desc1 = surfDescs[iCam];
std::vector<float>& desc2 = surfDescs[jCam];
int dim = m_descDim;
std::vector<cv::DMatch> matches1, matches2;
cv::Mat matDesc1(desc1.size() / dim, dim, CV_32F, &desc1[0]);
cv::Mat matDesc2(desc2.size() / dim, dim, CV_32F, &desc2[0]);
cv::BruteForceMatcher<cv::L2<float> > matcher;
matcher.match(matDesc1, matDesc2, matches1);
matcher.match(matDesc2, matDesc1, matches2);
//test
cv::Mat img1(m_img[iCam].rows, m_img[iCam].cols, CV_8UC1, m_img[iCam].data);
cv::Mat img2(m_img[jCam].rows, m_img[jCam].cols, CV_8UC1, m_img[jCam].data);
cv::Mat outImg;
cv::drawMatches(img1, surfPoints[iCam], img2, surfPoints[jCam], matches1, outImg);
cv::imwrite("/home/tsou/test.bmp", outImg);
//cross validation
std::vector<int> ind1;
ind1.assign(surfPoints[iCam].size(), -1);
for (size_t j = 0; j < matches1.size(); j++) {
int idx1 = matches1[j].queryIdx;
int idx2 = matches1[j].trainIdx;
ind1[idx1] = idx2;
}
matches.clear();
matches.reserve(matches2.size());
for (size_t j = 0; j < matches2.size(); j++) {
int idx2 = matches2[j].queryIdx;
int idx1 = matches2[j].trainIdx;
if (ind1[idx1] == idx2) {
matches.add(idx1, idx2, matches2[j].distance);
}
}
return matches.num;
}
//-------------------------------------
// Fire()
//-------------------------------------
void Bullet::Fire(OBJECT_PARAMETER_DESC ¶meter)
{
parameter_ = parameter;
speed_ = { BULLET_DEF_SPEED_XZ, BULLET_DEF_SPEED_Y, BULLET_DEF_SPEED_XZ };
// 回転値を少し調整
parameter_.rotation_.x_ += BULLET_OFFSET_ROT;
// 回転値を参照して速度を改良
speed_.y += sinf(parameter_.rotation_.x_) * BULLET_ADD_SPEED_Y;
if (collision_ == nullptr)
{
Scene *scene = SceneManager::GetCurrentScene();
std::string str = SceneManager::GetCurrentSceneName();
if (str != "Game" && str != "Matching"){
ASSERT_ERROR("弾が生成されるべきシーンではありません");
return;
}
COLLISION_PARAMETER_DESC param;
param.position_ = {
parameter_.position_.x_,
parameter_.position_.y_,
parameter_.position_.z_ };
param.range_ = 0.5f;
param.offset_ = { 0.0f, 0.0f, 0.0f };
if (str == "Game"){
Game *game = dynamic_cast<Game*>(scene);
collision_ = game->collision_manager()->Create(this, param);
}
if (str == "Matching"){
Matching *matching = dynamic_cast<Matching*>(scene);
collision_ = matching->collision_manager()->Create(this, param);
}
}
// 使用フラグOFF
use_ = true;
collision_->SetUse(true);
}
int main() {
int n, d;
int x[MAXN], y[MAXN];
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i], &y[i]);
}
scanf("%d", &d);
m.init(n);
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (abs(x[i] - x[j]) + abs(y[i] - y[j]) <= d) {
m.addEdge(i, j);
}
}
}
puts(m.gao() * 2 == n ? "YES" : "NO");
}
return 0;
}
void RGFlow<Two_scale>::run_down()
{
assert(models.size() > 0 && "model size must not be zero");
VERBOSE_MSG("< running tower down ...");
const size_t number_of_models = models.size();
for (long m = number_of_models - 1; m >= 0; --m) {
TModel* model = models[m];
VERBOSE_MSG("< \tselecting model " << model->model->name());
// apply all constraints:
// If m is the last model, do not apply the highest constraint,
// because it was already appied when we ran up.
const size_t c_begin = (m + 1 == (long)number_of_models ? 1 : 0);
const size_t c_end = model->downwards_constraints.size();
for (size_t c = c_begin; c < c_end; ++c) {
Constraint<Two_scale>* constraint = model->downwards_constraints[c];
const double scale = constraint->get_scale();
VERBOSE_MSG("< \t\tselecting constraint " << c << " at scale " << scale);
VERBOSE_MSG("< \t\t\trunning model to scale " << scale);
if (model->model->run_to(scale))
throw NonPerturbativeRunningError(scale);
// If m is the lowest energy model, do not apply the lowest
// constraint, because it will be applied when we run up next
// time.
if (m != 0 || c + 1 != c_end) {
VERBOSE_MSG("< \t\t\tapplying constraint");
constraint->apply();
}
}
// apply matching condition if this is not the first model
if (m > 0) {
Matching<Two_scale>* mc = models[m - 1]->matching_condition;
VERBOSE_MSG("< \tmatching to model " << models[m - 1]->model->name());
mc->match_high_to_low_scale_model();
}
}
VERBOSE_MSG("< running down finished");
}
Garden() {
fileLeft = getDataFile("stereo1.jpg"); // left image
fileRight = getDataFile("stereo2.jpg"); // right image
imgLeft = ImageFactory::readJPEG(fileLeft);
imgRight = ImageFactory::readJPEG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
// image1 // image2 (left of image1) // refine the approximate matching positions
Point2i pl1(85,53); Point2i pr1(29,57); pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(264,34); Point2i pr2(209,36); pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(362,32); Point2i pr3(306,32); pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(213,155); Point2i pr4(155,159); pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(96,209); Point2i pr5(36,210); pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(330,212); Point2i pr6(269,211); pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(276,241); Point2i pr7(216,242); pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(385,332); Point2i pr8(321,328); pr8 = matcher.refine(sad, pl8, pr8);
Point2i pl9(180,389); Point2i pr9(114,388); pr9 = matcher.refine(sad, pl9, pr9);
Point2i pl10(136,500); Point2i pr10(67,500); pr10 = matcher.refine(sad, pl10, pr10);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
// fm.addCorrespondence(pl9, pr9);
// fm.addCorrespondence(pl10, pr10);
fm.estimate();
}
bool GramError::Evaluate() {
ensure(scrutinizer); ensure(matchingSet);
ensure(matching);
Matching *m = matching;
matching = NULL;
ruleTerm = m->GetRuleTerm();
const AbstractSentence *s = sentence = m->GetSentence();
bool falseAlarm = false;
// create alt sentences:
m->SetAltSentence(NULL);
for (Expr* c = ruleTerm->GetCorr(); c; c = c->Next()) {
DynamicSentence *ds = new DynamicSentence(s);
DynamicSentence *prevAlt = m->GetAltSentence();
m->SetAltSentence(ds);
if (!m->GetRuleTerm()->EvaluateCorr(m, c))
Message(MSG_WARNING, "evaluation of corr failed", m->GetRule()->Name());
if (prevAlt) m->AddAltSentences(prevAlt);
}
// set status info:
DynamicSentence *d;
for (d = m->GetAltSentence(); d; d = d->Next()) {
if (d->Status() == FORM_NOT_FOUND)
continue;
if (s->IsEqual(d)) {
d->status = SAME_AS_ORIGINAL;
if (xSuggestionSameAsOriginalMeansFalseAlarm) {
falseAlarm = true;
break;
}
}
for (DynamicSentence *d2 = m->GetAltSentence(); d2 && d2 != d; d2 = d2->Next())
if (d2->Status() != FORM_NOT_FOUND && d->IsEqual(d2)) {
d->status = SAME_AS_ANOTHER;
break;
}
}
if (!falseAlarm) {
// extract info:
info = stringBuf.NewString(ruleTerm->EvaluateInfo(m));
if (*info == '\0')
Message(MSG_WARNING, "no info from", ruleTerm->GetRule()->Name());
// extract mark:
std::ostringstream out2;
if (ruleTerm->GetMark())
ruleTerm->EvaluateMark(m);
else
for (int i=m->Start(); i<= m->End(); i++)
s->GetWordToken(i)->SetMarked();
out2 << xRed;
bool gap = false, anyMark = false;
nMarkedSections = 0;
start[0] = stop[0] = -1;
int firstWTpos = (m->Start() >= 2) ? m->Start() : 2;
int lastWTpos = (m->End() >= s->NTokens()-2) ? s->NTokens()-3 : m->End();
for (int i=2; i<s->NTokens()-2; i++)
if (s->GetWordToken(i)->IsMarked()) {
if (!anyMark) firstWTpos = i;
lastWTpos = i;
anyMark = true;
s->GetWordToken(i)->SetMarked(0);
s->GetWordToken(i)->SetMarked2();
if (gap) { out2 << " ... "; gap = false; }
out2 << s->GetWordToken(i);
if (start[nMarkedSections] < 0)
start[nMarkedSections] = i;
stop[nMarkedSections] = i;
} else {
gap = anyMark;
if (start[nMarkedSections] >= 0) {
if (nMarkedSections >= MAX_MARKED_SECTIONS-1)
Message(MSG_WARNING, "too many marked sections");
nMarkedSections++;
start[nMarkedSections] = stop[nMarkedSections] = -1;
}
}
// jbfix: if the marked area ended in the last position
// nMarkedSections was not incremented
if(start[nMarkedSections] != -1)
{
if(nMarkedSections >= MAX_MARKED_SECTIONS-1)
Message(MSG_WARNING, "too many marked sections");
nMarkedSections++;
}
if (!anyMark) {
Message(MSG_WARNING, "nothing marked with", ruleTerm->GetRule()->Name());
start[0] = firstWTpos;
stop[0] = lastWTpos;
nMarkedSections = 1;
} else if (firstWTpos <= 2 && lastWTpos >= s->NTokens()-3) {
allMarked = true;
markedArea = "";
start[0] = firstWTpos;
stop[0] = lastWTpos;
nMarkedSections = 1;
} else {
out2 << xNoColor << '\0';
markedArea = stringBuf.NewString(out2.str().c_str());
}
// jb: mem is now handled by std::string
//if (str) delete str; else delete out2.str();
// create suggestions:
for (d = m->GetAltSentence(); d; d = d->Next()) {
if (nSuggestions >= MAX_SUGGESTIONS) {
Message(MSG_WARNING, "too many suggestions");
break;
}
switch (d->Status()) {
case FORM_NOT_FOUND:
nErrors[nSuggestions] = 0;
suggestion[nSuggestions++] = stringBuf.NewString("FORM NOT FOUND");
continue;
case SAME_AS_ANOTHER:
if (xAcceptRepeatedSuggestions) break;
continue;
case NOT_IMPROVING: ensure(0);
case SAME_AS_ORIGINAL:
case SEEMS_OK:
break;
}
d->TagMe();
matchingSet->SetCheckMode(true);
scrutinizer->Scrutinize(d);
nErrors[nSuggestions] = (char) matchingSet->NCheckModeFound();
matchingSet->SetCheckMode(false);
if (nErrors[nSuggestions] >= sentence->NGramErrors())
d->status = NOT_IMPROVING;
if (xPrintMatchings) {
std::cout << tab;
switch(d->Status()) {
case SEEMS_OK: std::cout << "(OK)"; break;
case SAME_AS_ORIGINAL: std::cout << "(NO CHANGES)"; break;
case SAME_AS_ANOTHER: std::cout << "(REPEATED)"; break;
case NOT_IMPROVING: std::cout << "(NOT IMPROVING)"; break;
case FORM_NOT_FOUND: std::cout << "(FORM NOT FOUND)"; break;
}
std::cout << std::endl;
}
if (!xAcceptNonImprovingCorrections && d->Status() == NOT_IMPROVING)
continue;
std::ostringstream out;
d->PrintOrgRange(firstWTpos, lastWTpos, out);
switch(d->Status()) {
case SEEMS_OK: break;
case SAME_AS_ORIGINAL: out << " (NO CHANGES)"; break;
case SAME_AS_ANOTHER: out << " (REPEATED)"; break;
case NOT_IMPROVING: out << " (NOT IMPROVING, gives " << (int)nErrors[nSuggestions]
<< " errors, " << sentence->NGramErrors() << " before)"; break;
case FORM_NOT_FOUND: ensure(0); break;
}
out << '\0';
// suggestion[nSuggestions++] = stringBuf.NewString(out.str().c_str());
suggestion[nSuggestions++] = stringBuf.NewString(move_xmltag_and_space(out.str()).c_str());
}
}
// delete alt sentences:
DynamicSentence *nxt = NULL;
for (d = m->GetAltSentence(); d; d = nxt) {
nxt = d->Next();
delete d;
}
m->SetAltSentence(NULL);
// std::cout << this << std::endl;
return !falseAlarm;
}
//-------------------------------------
// Update()
//-------------------------------------
void Bullet::Update()
{
if (!use_)
{
return;
}
parameter_.position_.x_ += sinf(parameter_.rotation_.y_) * speed_.x;
parameter_.position_.y_ += speed_.y;
parameter_.position_.z_ += cosf(parameter_.rotation_.y_) * speed_.z;
speed_.y -= BULLET_GRAVITY;
Scene *scene = SceneManager::GetCurrentScene();
std::string str = SceneManager::GetCurrentSceneName();
if (str == "Game"){
Game *game = dynamic_cast<Game*>(scene);
Object *obj = game->object_manager()->Get("field");
Field *field = dynamic_cast<Field*>(obj);
float height = field->GetHeight(
D3DXVECTOR3(
parameter_.position_.x_,
parameter_.position_.y_,
parameter_.position_.z_));
if (parameter_.position_.y_ < height){
use_ = false;
collision_->SetUse(false);
//-------------------------------------
// シーンからエフェクト取得
EFFECT_PARAMETER_DESC effect_param;
MyEffect *effect = game->effect_manager()->Get("fieldhit");
effect_param = effect->parameter();
effect_param.position_ = parameter_.position_;
effect_param.position_.y_ = height;
effect_param.rotation_ = { 0.0f, parameter_.rotation_.y_, 0.0f };
effect->SetParameter(effect_param);
//-------------------------------------
// エフェクト再生
game->effect_manager()->Play("fieldhit");
parameter_.position_.y_ = 10000.0f;
}
}
if (str == "Matching"){
Matching *matching = dynamic_cast<Matching*>(scene);
Object *obj = matching->object_manager()->Get("field");
Field *field = dynamic_cast<Field*>(obj);
float height = field->GetHeight(
D3DXVECTOR3(
parameter_.position_.x_,
parameter_.position_.y_,
parameter_.position_.z_));
if (parameter_.position_.y_ < height){
use_ = false;
collision_->SetUse(false);
parameter_.position_.y_ = 10000.0f;
//-------------------------------------
// シーンからエフェクト取得
EFFECT_PARAMETER_DESC effect_param;
MyEffect *effect = matching->effect_manager()->Get("fieldhit");
effect_param = effect->parameter();
effect_param.position_ = parameter_.position_;
effect_param.position_.y_ = height;
effect_param.rotation_ = { 0.0f, parameter_.rotation_.y_, 0.0f };
effect->SetParameter(effect_param);
//-------------------------------------
// エフェクト再生
matching->effect_manager()->Play("fieldhit");
}
}
// ワールド計算
D3DXMATRIX translate, rotate, scaling;
D3DXMatrixIdentity(&translate);
D3DXMatrixIdentity(&rotate);
D3DXMatrixIdentity(&scaling);
D3DXMatrixIdentity(&world_);
D3DXMatrixScaling(
&scaling, parameter_.scaling_.x_, parameter_.scaling_.y_, parameter_.scaling_.z_);
D3DXMatrixMultiply(
&world_, &world_, &scaling);
D3DXMatrixRotationYawPitchRoll(
&rotate, parameter_.rotation_.y_, parameter_.rotation_.x_, parameter_.rotation_.z_);
D3DXMatrixMultiply(
&world_, &world_, &rotate);
D3DXMatrixTranslation(
&translate, parameter_.position_.x_, parameter_.position_.y_, parameter_.position_.z_);
D3DXMatrixMultiply(
&world_, &world_, &translate);
}
