int main(int argc, const char * argv[]) {
if(argc < 2){
std::cerr << "Requires a filename to run" << std::endl;
exit(-1);
}
std::string fileName = argv[1];
std::ifstream file(fileName);
LDParse::ColorTable colors;
LDParse::ModelBuilder<LDParse::ErrF> modelBuilder(errF);
LDParse::Model * model = modelBuilder.construct(fileName, fileName, file, colors);
/*
std::cout << "Model " << fileName << " is " << (isMPD ? "" : "not ") << " an MPD" << std::endl;
if(isMPD) std::cout << "\t" << "root model is " << rootName << std::endl << std::endl;
for(auto it = models.begin(); it != models.end(); ++it){
if(isMPD) std::cout << "// " << (it->first.compare(rootName) ? "sub" : "root") << "-model, " << it->first << std::endl << std::endl;
for(auto fIt = it->second.begin(); fIt != it->second.end(); ++fIt){
for(size_t i = 0; i < fIt->size(); i++){
std::cout << (*fIt)[i];
}
std::cout << std::endl;
}
std::cout << std::endl << std::endl;
}
*/
return 0;
}
void ResourceThreadModel::Load(const ResourceRequest& request)
{
DALI_ASSERT_DEBUG(request.GetType()->id == ResourceModel);
DALI_LOG_INFO(mLogFilter, Debug::Verbose, "%s(%s)\n", __PRETTY_FUNCTION__, request.GetPath().c_str());
scoped_ptr<ModelBuilder> modelBuilder( CreateModelBuilder(request.GetPath()) );
ModelData modelData = ModelData::New(modelBuilder->GetModelName());
const bool success = modelBuilder->Build(modelData);
if( success )
{
// Construct LoadedResource and ResourcePointer for model data
LoadedResource resource( request.GetId(), request.GetType()->id, ResourcePointer(&(modelData.GetBaseObject())));
// Queue the loaded resource
mResourceLoader.AddLoadedResource(resource);
}
else
{
// add to the failed queue
FailedResource resource(request.GetId(), FailureUnknown);
mResourceLoader.AddFailedLoad(resource);
}
}
void ResourceThreadModel::Save(const ResourceRequest& request)
{
DALI_ASSERT_DEBUG(request.GetType()->id == ResourceModel);
DALI_LOG_INFO(mLogFilter, Debug::Verbose, "%s(%s)\n", __PRETTY_FUNCTION__, request.GetPath().c_str());
bool success(false);
BaseObject* baseObject = dynamic_cast<BaseObject*>(request.GetResource().Get());
if( baseObject != NULL )
{
BaseHandle baseHandle(baseObject);
ModelData modelData = ModelData::DownCast(baseHandle);
if( modelData )
{
scoped_ptr<BinaryModelBuilder> modelBuilder (new BinaryModelBuilder(request.GetPath().c_str()));
if ( modelBuilder->Write(modelData) )
{
success = true;
// Construct SavedResource
SavedResource resource( request.GetId(), request.GetType()->id);
// Queue the loaded resource
mResourceLoader.AddSavedResource(resource);
}
}
}
if( ! success )
{
// add to the failed queue
FailedResource resource(request.GetId(), FailureUnknown);
mResourceLoader.AddFailedSave(resource);
}
}
// evaluate the probabilty of each point before using it as a prior
SEXP PosteriorModelSafe(SEXP pPCA_,SEXP sample_, SEXP mean_, SEXP ptValueNoise_,SEXP maha_) {
try {
double maha = as<double>(maha_);
NumericMatrix ptValueNoise(ptValueNoise_);
NumericMatrix sample(sample_);
NumericMatrix mean(mean_);
shared_ptr<vtkMeshModel> model = pPCA2statismo(pPCA_);
PointValueListType ptValueList;
PointValueWithCovarianceListType ptValueWithCovPair;
shared_ptr<ModelBuilderType> modelBuilder(ModelBuilderType::Create());
for (int i = 0; i < mean.ncol();i++) {
vtkPoint tmp0 = SEXP2vtkPoint(wrap(sample(_,i)));
vtkPoint tmp1 = SEXP2vtkPoint(wrap(mean(_,i)));
double mahaget = mahadist(model.get(),tmp0,tmp1);
if (mahaget <= maha) {
if (ptValueNoise.nrow() == 1) {
ptValueList.push_back(PointValuePairType(tmp1,tmp0));
} else {
MatrixType tmpcov = Eigen::MatrixXf::Identity(3, 3) * ptValueNoise(i,0);
PointValuePairType tmppair = PointValuePairType(tmp1,tmp0);
PointValueWithCovariancePairType covpair = PointValueWithCovariancePairType(tmppair,tmpcov);
ptValueWithCovPair.push_back(covpair);
}
}
}
if (ptValueNoise.nrow() == 1) {
double noise = ptValueNoise(0,0);
shared_ptr<vtkMeshModel> postModel(modelBuilder->BuildNewModelFromModel(model.get(), ptValueList,noise));
return statismo2pPCA(postModel);
} else {
shared_ptr<vtkMeshModel> postModel(modelBuilder->BuildNewModelFromModel(model.get(),ptValueWithCovPair));
return statismo2pPCA(postModel);
}
} catch (std::exception& e) {
::Rf_error( e.what());
} catch (...) {
::Rf_error("unknown exception");
}
}
shared_ptr<vtkMeshModel> BuildGPModel(SEXP pPCA_,SEXP kernels_, SEXP ncomp_,SEXP nystroem_,SEXP useEmp_, SEXP combine_,SEXP combineEmp_, SEXP isoScale_, SEXP centroid_) {
try {
bool useEmp = as<bool>(useEmp_);
int combine = as<int>(combine_);
int combineEmp = as<int>(combineEmp_);
double isoScale = as<double>(isoScale_);
unsigned int nystroem = as<unsigned int>(nystroem_);
unsigned int numberOfComponents = as<unsigned int>(ncomp_);
std::list<MatrixValuedKernelType*> mKerns;
std::list<GaussianKernel*> gKerns;
std::list<MultiscaleKernel*> bsKerns;
vtkPoint centroid = SEXP2vtkPoint(centroid_);
List kernels(kernels_);
shared_ptr<vtkMeshModel> model = pPCA2statismo(pPCA_);
MatrixValuedKernelType* mvKernel;
// set up the gaussian kernel to be incremented over a list of parameters
NumericVector params = kernels[0];
//if params[0] == 0 Gaussian Kernel
//else Multiscale kernel
if (params.size() == 2) {
GaussianKernel* gk = new GaussianKernel(params[0]);
gKerns.push_back(gk);
mvKernel = new UncorrelatedMatrixValuedKernel<vtkPoint>(gk, model->GetRepresenter()->GetDimensions());
} else {
MultiscaleKernel* gk1 = new MultiscaleKernel(params[0],params[2]);
bsKerns.push_back(gk1);
mvKernel = new UncorrelatedMatrixValuedKernel<vtkPoint>(gk1, model->GetRepresenter()->GetDimensions());
}
MatrixValuedKernelType* sumKernel = new ScaledKernel<vtkPoint>(mvKernel, params[1]);
//iterate over the remaining kernel parameters
for (unsigned int i = 1; i < kernels.size();i++) {
params = kernels[i];
GaussianKernel* gkNew = new GaussianKernel(params[0]);
MatrixValuedKernelType* mvGk = new UncorrelatedMatrixValuedKernel<vtkPoint>(gkNew, model->GetRepresenter()->GetDimensions());
MatrixValuedKernelType* scaledGk = new ScaledKernel<vtkPoint>(mvGk, params[1]);
//keep track of allocated objects
gKerns.push_back(gkNew);
mKerns.push_back(mvGk);
mKerns.push_back(scaledGk);
if (combine == 0)
sumKernel = new SumKernel<vtkPoint>(sumKernel, scaledGk);
else
sumKernel = new ProductKernel<vtkPoint>(sumKernel, scaledGk);
}
if (useEmp) {
// get the empiric kernel
MatrixValuedKernelType* statModelKernel = new StatisticalModelKernel<vtkPolyData>(model.get());
mKerns.push_back(statModelKernel);
// add the empiric kernel on top
if (combineEmp == 0)
sumKernel = new SumKernel<vtkPoint>(sumKernel, statModelKernel);
else
sumKernel = new ProductKernel<vtkPoint>(sumKernel, statModelKernel);
}
if (isoScale > 0) {
MatrixValuedKernelType* isoKernel = new IsoKernel(3,isoScale,centroid);
mKerns.push_back(isoKernel);
sumKernel = new SumKernel<vtkPoint>(sumKernel, isoKernel);
}
mKerns.push_back(sumKernel);
//build new model
shared_ptr<ModelBuilderType> modelBuilder(ModelBuilderType::Create(model->GetRepresenter()));
shared_ptr<vtkMeshModel> combinedModel(modelBuilder->BuildNewModel(model->DrawMean(), *sumKernel, numberOfComponents,nystroem));
//tidy up
for (std::list<MatrixValuedKernelType*>::iterator it = mKerns.begin(); it != mKerns.end(); it++) {
if (*it != NULL) {
delete *it;
}
}
for (std::list<GaussianKernel*>::iterator it = gKerns.begin(); it != gKerns.end(); it++) {
if (*it != NULL) {
delete *it;
}
}
for (std::list<MultiscaleKernel*>::iterator it = bsKerns.begin(); it != bsKerns.end(); it++) {
if (*it != NULL) {
delete *it;
}
}
return combinedModel;
} catch (StatisticalModelException& e) {
::Rf_error("Exception occured while building the shape model\n");
::Rf_error("%s\n", e.what());
//shared_ptr<vtkMeshModel> model(NULL);
//return model;
} catch (std::exception& e) {
::Rf_error( e.what());
//shared_ptr<vtkMeshModel> model(NULL);
//return model;
} catch (...) {
::Rf_error("unknown exception");
//shared_ptr<vtkMeshModel> model(NULL);
//return model;
}
}
