void load_volume_node(tinyxml2::XMLElement *elem, Scene &scene, std::stack<Transform> &transform_stack, const std::string &file){
if (!elem->Attribute("name")){
std::cout << "Scene error: Volume nodes require a name" << std::endl;
std::exit(1);
}
std::string name = elem->Attribute("name");
Transform t;
read_transform(elem, t);
t = transform_stack.top() * t;
Volume *vol = load_volume(elem->FirstChildElement("volume"), scene.get_volume_cache(), file);
if (!vol){
std::cout << "Scene error: could not load volume attached to volume node " << name << std::endl;
std::exit(1);
}
if (scene.get_volume_root() == nullptr){
scene.set_volume_root(std::make_unique<VolumeNode>(vol, t, name));
}
else {
auto &children = scene.get_volume_root()->get_children();
children.push_back(std::make_unique<VolumeNode>(vol, t, name));
}
transform_stack.push(t);
}
int
main(int argc,
char* argv[])
{
IoParams params;
try
{
params.parse(argc,argv);
}
catch (const std::exception& excp)
{
std::cerr << " Exception while parsing cmd-line\n"
<< excp.what() << std::endl;
exit(1);
}
catch (...)
{
std::cerr << " unhandled exception caught while parsing cmd line\n";
exit(1);
}
boost::shared_ptr<gmp::VolumeMorph> pmorph(new gmp::VolumeMorph);
if ( !params.strTemplate.empty() )
{
MRI* mri = MRIread( const_cast<char*>(params.strTemplate.c_str()) );
if (!mri)
std::cerr << " Failed to open template mri "
<< params.strTemplate << std::endl;
else
pmorph->set_volGeom_fixed(mri);
MRIfree(&mri);
}
if ( !params.strSubject.empty() )
{
MRI* mri = MRIread( const_cast<char*>(params.strSubject.c_str()) );
if (!mri)
std::cerr << " Failed to open subject mri "
<< params.strSubject << std::endl;
else
pmorph->set_volGeom_moving(mri);
MRIfree(&mri);
}
IoParams::MorphContainerType::iterator it;
for ( it = params.items.begin();
it != params.items.end();
++it )
{
if ( it->type == "affine" )
{
boost::shared_ptr<gmp::AffineTransform3d>
paffine( new gmp::AffineTransform3d);
float* pf = read_transform( it->file.c_str() );
if ( !pf )
{
std::cerr << " failed to read transform\n";
exit(1);
}
paffine->set_pars( pf);
pmorph->m_transforms.push_back( paffine );
}
else if ( it->type == "volume" )
{
boost::shared_ptr<gmp::DeltaTransform3d>
pvol( new gmp::DeltaTransform3d);
MRI* field = MRIread
( const_cast<char*>( it->file.c_str() ) );
if ( !field )
{
std::cerr << " failed to read field " << std::endl;
exit(1);
}
pvol->set_field(field);
pmorph->m_transforms.push_back( pvol );
}
else if ( it->type == "gcam" )
{
boost::shared_ptr<gmp::DeltaTransform3d>
pvol( new gmp::DeltaTransform3d);
GCA_MORPH* gcam = GCAMread( const_cast<char*>( it->file.c_str() ) );
if ( !gcam )
{
std::cerr << " failed to read GCAM " << std::endl;
exit(1);
}
// create bogus MRI to hold the geometry
MRI* mri_template = MRIread( const_cast<char*>
( params.strTemplate.c_str() ) );
MRI* mriBuf = MRIalloc( gcam->image.width,
gcam->image.height,
gcam->image.depth,
MRI_UCHAR);
useVolGeomToMRI( &gcam->image, mriBuf );
GCAMrasToVox(gcam, mriBuf );
MRIfree( &mriBuf );
std::cout << " atlas geometry = "
<< gcam->atlas.width << " , " << gcam->atlas.height
<< " , " << gcam->atlas.depth << std::endl
<< " image geometry = "
<< gcam->image.width << " , " << gcam->image.height
<< " , " << gcam->image.depth << std::endl;
MRI* mri = MRIallocSequence( mri_template->width,
mri_template->height,
mri_template->depth,
MRI_FLOAT,
3);
MRIcopyHeader(mri_template, mri);
g_vDbgCoords = params.vDbgCoords;
try
{
//MRI* mask =
CopyGcamToDeltaField(gcam, mri);
pvol->set_field(mri);
//pvol->set_mask(mask);
pmorph->m_transforms.push_back( pvol );
}
catch (const std::string& e)
{
std::cerr << " Exception caught while processing GCAM node\n"
<< e << std::endl;
exit(1);
}
MRIfree(&mri_template);
}
else if ( it->type == "morph" )
{
boost::shared_ptr<gmp::VolumeMorph> tmpMorph(new gmp::VolumeMorph);
try
{
tmpMorph->load( it->file.c_str() );
}
catch (const char* msg)
{
std::cerr << " Exception caught while loading morph in file "
<< it->file << std::endl;
exit(1);
}
for ( gmp::VolumeMorph::TransformContainerType::iterator transformIter
= tmpMorph->m_transforms.begin();
transformIter != tmpMorph->m_transforms.end();
++transformIter )
pmorph->m_transforms.push_back( *transformIter );
}
else if ( it->type == "mesh" )
{
boost::shared_ptr<gmp::FemTransform3d> pfem(new gmp::FemTransform3d);
boost::shared_ptr<CMesh3d> pmesh(new CMesh3d);
pmesh->load( it->file.c_str() );
pfem->m_sharedMesh = pmesh;
pmorph->m_transforms.push_back(pfem);
}
else
{
std::cerr << " unhandled transform type "
<< it->type << std::endl;
}
} // next it
// finally write morph file
try
{
pmorph->save( params.strOut.c_str() );
}
catch (const char* msg)
{
std::cerr << " Exception caught while saving morph\n"
<< msg << std::endl;
exit(1);
}
return 0;
}
gint read_frame(FILE *fp, gint n, struct model_pak *model)
{
gint status;
gdouble rmax, v1[3], v2[3];
gpointer camera=NULL;
GString *err_text;
g_assert(model != NULL);
rmax = model->rmax;
/* conventional or transformation style animation */
if (model->transform_list)
{
/* NEW - process transformation list as an animation */
status = read_transform(n, model);
}
else
{
g_assert(fp != NULL);
ARR3SET(v1, model->centroid);
ARR3SET(v2, model->offset);
status = read_raw_frame(fp, n, model);
if (status)
{
err_text = g_string_new("");
g_string_printf(err_text, "Error reading frame: %d\n", n);
gui_text_show(ERROR, err_text->str);
g_string_free(err_text, TRUE);
return(1);
}
/* setup (have to save camera) */
camera = camera_dup(model->camera);
model_prep(model);
model->camera = camera;
g_free(model->camera_default);
model->camera_default = camera;
ARR3SET(model->centroid, v1);
ARR3SET(model->offset, v2);
}
/* apply desired constraint */
if (model->periodic && !model->anim_fix)
{
switch (model->anim_confine)
{
case PBC_CONFINE_ATOMS:
coords_confine_cores(model->cores, model);
case PBC_CONFINE_MOLS:
coords_compute(model);
connect_bonds(model);
connect_molecules(model);
break;
}
}
if (model->anim_noscale)
model->rmax = rmax;
return(0);
}
