Foam::dimensionedScalar Foam::engineTime::pistonDisplacement() const
{
return dimensionedScalar
(
"pistonDisplacement",
dimLength,
pistonPosition(theta() - deltaTheta()) - pistonPosition().value()
);
}
int CascadedPoseRegression::LearnRegression(const std::vector<std::string>& imgFiles, const std::vector<double>& initTheta,
const std::vector<double>& finalTheta, int dataPerImgCount, int thetaDim, int fernCount, int fernSize, int featureSize)
{
if (thetaDim < 1 || imgFiles.size() == 0)
{
return MAGIC_INVALID_INPUT;
}
if (imgFiles.size() * dataPerImgCount != finalTheta.size() / thetaDim)
{
return MAGIC_INVALID_INPUT;
}
Reset();
//ImageLoader imageLoader;
//imageLoader.LoadImages(imgFiles, ImageLoader::IT_Gray);
DebugLog << "Load Image......";
mImageLoader.LoadImages(imgFiles, ImageLoader::IT_Gray);
DebugLog << "done" << std::endl;
srand(time(NULL));
mRandomFerns.reserve(fernCount);
int dataCount = initTheta.size() / thetaDim;
////Construct mImageList
//mImageList.reserve(dataCount);
//for (int dataId = 0; dataId < 1000; dataId++)
//{
// DebugLog << " image: " << dataId << std::endl;
// cv::Mat* pImage = new cv::Mat;
// *pImage = cv::imread(imgFiles.at(dataId));
// mImageList.push_back(pImage);
//}
////
std::vector<bool> dataX(featureSize * dataCount);
std::vector<double> theta(thetaDim); //one theta
std::vector<double> curTheta = initTheta;
std::vector<double> deltaTheta(curTheta.size());
for (int fernId = 0; fernId < fernCount; fernId++)
{
//double timeStart = MagicCore::ToolKit::GetTime();
DebugLog << "fernId: " << fernId << std::endl;
//Calculate deltaTheta
/*for (int dataId = 0; dataId < dataCount; dataId++)
{
if (dataId % 5000 != 0)
{
continue;
}
DebugLog << " Cur" << dataId << ": " << curTheta.at(dataId * 2) << " " << curTheta.at(dataId * 2 + 1) << std::endl;
DebugLog << " Tar" << dataId << ": " << finalTheta.at(dataId * 2) << " " << finalTheta.at(dataId * 2 + 1) << std::endl;
}*/
double avgDelta = 0;
for (int thetaId = 0; thetaId < curTheta.size(); thetaId++)
{
deltaTheta.at(thetaId) = finalTheta.at(thetaId) - curTheta.at(thetaId);
avgDelta += fabs(deltaTheta.at(thetaId));
}
avgDelta /= curTheta.size();
DebugLog << " AvgDelta: " << avgDelta << std::endl;
/*if (avgDelta < 0.1)
{
break;
}*/
//Generate Feature Ids and dataX
FeaturePatternGeneration(curTheta, deltaTheta, dataPerImgCount, dataCount, featureSize, dataX);
DebugLog << " FeaturePatternGeneration done" << std::endl;
//Learn random fern
MagicML::RandomFern* pFern = new MagicML::RandomFern;
pFern->Learn(dataX, featureSize, deltaTheta, thetaDim, fernSize);
DebugLog << " Fern Learn done" << std::endl;
mRandomFerns.push_back(pFern);
//Update Valid Features
std::vector<int> validFeatureIds = pFern->GetFeatureIds();
UpdateValidFeaturePosPair(validFeatureIds);
DebugLog << " UpdateValidFeaturePosPair done" << std::endl;
//Update curTheta
for (int dataId = 0; dataId < dataCount; dataId++)
{
//Load image
//cv::Mat img = cv::imread(imgFiles.at(dataId));
//cv::Mat img = cv::imread(imgFiles.at(dataId));
//DebugLog << " imgOrigin susscess : " << imgFiles.at(dataId) << std::endl;
//if (img.data == NULL)
//{
// DebugLog << " error: img.data == NULL" << std::endl;
//}
//Generate feature from theta
int baseIndex = dataId * thetaDim;
for (int thetaId = 0; thetaId < thetaDim; thetaId++)
{
theta.at(thetaId) = curTheta.at(baseIndex + thetaId);
}
std::vector<bool> features;
//ValidFeatureGeneration(img, theta, fernId, features);
int imgId = dataId / dataPerImgCount;
ValidFeatureGenerationByImageLoader(imgId, theta, fernId, features);
//DebugLog << " ValidFeatureGeneration" << std::endl;
//img.release();
//DebugLog << " img release" << std::endl;
//Predict delta theta
std::vector<double> predictDelta = pFern->PredictWithValidFeature(features);
//DebugLog << " Fern Prediction " << deltaTheta.at(0) << " " << deltaTheta.at(1) << std::endl;
//Update curTheta
baseIndex = dataId * thetaDim;
for (int thetaId = 0; thetaId < thetaDim; thetaId++)
{
curTheta.at(baseIndex + thetaId) += predictDelta.at(thetaId);
}
}
//DebugLog << " time: " << MagicCore::ToolKit::GetTime() - timeStart << std::endl;
}
//free mImageList
/*for (int dataId = 0; dataId < dataCount; dataId++)
{
if (mImageList.at(dataId) != NULL)
{
mImageList.at(dataId)->release();
delete mImageList.at(dataId);
mImageList.at(dataId) = NULL;
}
}
mImageList.clear();*/
return MAGIC_NO_ERROR;
}
int ExplicitShapeRegression::LearnRegression(const std::vector<std::string>& imgFiles, const std::vector<double>& initTheta,
const std::vector<double>& finalTheta, int dataPerImgCount, int keyPointCount, int outerCount, int innerCount,
int fernSize, int featureSizePerKey)
{
if (imgFiles.size() == 0 || initTheta.size() == 0 || finalTheta.size() == 0)
{
return MAGIC_INVALID_INPUT;
}
if (imgFiles.size() * dataPerImgCount != finalTheta.size() / (keyPointCount * 2))
{
return MAGIC_INVALID_INPUT;
}
Reset();
mInnerFernCount = innerCount;
//ImageLoader imageLoader;
DebugLog << "Load Image......";
mImageLoader.LoadImages(imgFiles, ImageLoader::IT_Gray);
DebugLog << "done" << std::endl;
srand(time(NULL));
int thetaDim = keyPointCount * 2;
int fernCount = outerCount * innerCount;
mRandomFerns.reserve(fernCount);
int dataCount = initTheta.size() / thetaDim;
std::vector<bool> dataX(featureSizePerKey * keyPointCount * dataCount);
std::vector<double> theta(thetaDim); //one theta
std::vector<double> curTheta = initTheta;
std::vector<double> interTheta;
std::vector<double> deltaTheta(curTheta.size());
bool earlyStop = false;
for (int outerId = 0; outerId < outerCount; outerId++)
{
if (earlyStop)
{
break;
}
double timeStart = MagicTool::Profiler::GetTime();
DebugLog << "Out stage: " << outerId << std::endl;
interTheta = curTheta;
for (int thetaId = 0; thetaId < interTheta.size(); thetaId++)
{
deltaTheta.at(thetaId) = finalTheta.at(thetaId) - interTheta.at(thetaId);
}
FeaturePatternGeneration(interTheta, deltaTheta, dataPerImgCount, dataCount, featureSizePerKey, keyPointCount, dataX);
int fernBaseId = outerId * mInnerFernCount;
for (int innerId = 0; innerId < mInnerFernCount; innerId++)
{
DebugLog << " Inner stage: " << innerId << " fernId: " << fernBaseId + innerId << std::endl;
int fernId = fernBaseId + innerId;
double avgDelta = 0;
for (int thetaId = 0; thetaId < curTheta.size(); thetaId++)
{
deltaTheta.at(thetaId) = finalTheta.at(thetaId) - curTheta.at(thetaId);
avgDelta += fabs(deltaTheta.at(thetaId));
}
avgDelta /= curTheta.size();
DebugLog << " AvgDelta: " << avgDelta << std::endl;
if (avgDelta < 0.5) //modify_flag
{
earlyStop = true;
}
MagicML::RandomFern* pFern = new MagicML::RandomFern;
pFern->Learn(dataX, featureSizePerKey * keyPointCount, deltaTheta, thetaDim, fernSize);
mRandomFerns.push_back(pFern);
//Update Valid Features
std::vector<int> validFeatureIds = pFern->GetFeatureIds();
/*DebugLog << " ValidFeatureIds: ";
for (std::vector<int>::iterator itr = validFeatureIds.begin(); itr != validFeatureIds.end(); itr++)
{
DebugLog << *itr << " ";
}
DebugLog << std::endl;*/
UpdateValidFeaturePosPair(validFeatureIds);
//Update curTheta
for (int dataId = 0; dataId < dataCount; dataId++)
{
//Generate feature from theta
int baseIndex = dataId * thetaDim;
for (int thetaId = 0; thetaId < thetaDim; thetaId++)
{
//theta.at(thetaId) = curTheta.at(baseIndex + thetaId);
theta.at(thetaId) = interTheta.at(baseIndex + thetaId);
}
std::vector<bool> features;
int imgId = dataId / dataPerImgCount;
ValidFeatureGenerationByImageLoader(imgId, theta, fernId, features);
//Predict delta theta
std::vector<double> predictDelta = pFern->PredictWithValidFeature(features);
//Update curTheta
baseIndex = dataId * thetaDim;
for (int thetaId = 0; thetaId < thetaDim; thetaId++)
{
curTheta.at(baseIndex + thetaId) += predictDelta.at(thetaId);
}
}
}
DebugLog << "time: " << MagicTool::Profiler::GetTime() - timeStart << std::endl;
Save("./temp.shape");
}
return MAGIC_NO_ERROR;
}
