//------------------------------
bool SceneGraphWriter::write( )
{
createUniqueIdNodeMap();
NodeInfo nodeInfo( COLLADABU::Math::Matrix4::IDENTITY );
mNodeInfoStack.push( nodeInfo );
writeNodes( mVisualScene.getRootNodes());
return true;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AbaqusSurfaceMeshWriter::execute()
{
int err = 0;
std::stringstream ss;
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
dataCheck(false, 1, 1, 1);
if(getErrorCondition() < 0)
{
return;
}
// Make sure any directory path is also available as the user may have just typed
// in a path without actually creating the full path
std::string parentPath = MXAFileInfo::parentPath(getOutputFile());
if(!MXADir::mkdir(parentPath, true))
{
std::stringstream ss;
ss << "Error creating parent path '" << parentPath << "'";
notifyErrorMessage(ss.str(), -1);
setErrorCondition(-1);
return;
}
DREAM3D::SurfaceMesh::VertListPointer_t nodesPtr = sm->getVertices();
DREAM3D::SurfaceMesh::FaceListPointer_t trianglePtr = sm->getFaces();
// Get the Labels(GrainIds or Region Ids) for the triangles
Int32ArrayType::Pointer faceLabelsPtr = boost::dynamic_pointer_cast<Int32ArrayType>(sm->getFaceData(DREAM3D::FaceData::SurfaceMeshFaceLabels));
int32_t* faceLabels = faceLabelsPtr->GetPointer(0);
// Store all the unique Spins
std::set<int> uniqueSpins;
for (int i = 0; i < trianglePtr->GetNumberOfTuples(); i++)
{
uniqueSpins.insert(faceLabels[i*2]);
uniqueSpins.insert(faceLabels[i*2+1]);
}
FILE* f = fopen(m_OutputFile.c_str(), "wb");
ScopedFileMonitor fileMonitor(f);
err = writeHeader(f, nodesPtr->GetNumberOfTuples(), trianglePtr->GetNumberOfTuples(), uniqueSpins.size()-1);
err = writeNodes(f);
err = writeTriangles(f);
err = writeGrains(f);
setErrorCondition(0);
notifyStatusMessage("Complete");
return;
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static methods
// ---------------------------------------------------------------------------
void
NWWriter_XML::writeNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
// check whether plain-output files shall be generated
if (oc.isSet("plain-output-prefix")) {
writeNodes(oc, nb.getNodeCont());
writeEdgesAndConnections(oc, nb.getNodeCont(), nb.getEdgeCont());
writeTrafficLights(oc, nb.getTLLogicCont(), nb.getEdgeCont());
}
if (oc.isSet("junctions.join-output")) {
writeJoinedJunctions(oc, nb.getNodeCont());
}
if (oc.isSet("street-sign-output")) {
writeStreetSigns(oc, nb.getEdgeCont());
}
}
//------------------------------
bool SceneGraphWriter::writeNode(const COLLADAFW::Node* nodeToWriter )
{
const NodeInfo& parentNodeInfo = mNodeInfoStack.top();
const COLLADABU::Math::Matrix4& parentWorldMatrix = parentNodeInfo.worldTransformation;
COLLADABU::Math::Matrix4 worldMatrix = parentWorldMatrix * nodeToWriter->getTransformationMatrix();
NodeInfo nodeInfo( worldMatrix );
mNodeInfoStack.push(nodeInfo);
writeNodes(nodeToWriter->getChildNodes());
storeInstanceGeometries( nodeToWriter->getInstanceGeometries(), worldMatrix);
writeInstanceNodes( nodeToWriter->getInstanceNodes() );
mNodeInfoStack.pop();
return true;
}
void SceneExporter::exportHierarchy(Scene *sce)
{
LinkNode *node;
std::vector<Object *> base_objects;
// Ensure all objects in the export_set are marked
for (node = this->export_settings->export_set; node; node = node->next) {
Object *ob = (Object *) node->link;
ob->id.flag |= LIB_DOIT;
}
// Now find all exportable base ojects (highest in export hierarchy)
for (node = this->export_settings->export_set; node; node = node->next) {
Object *ob = (Object *) node->link;
if (bc_is_base_node(this->export_settings->export_set, ob)) {
switch (ob->type) {
case OB_MESH:
case OB_CAMERA:
case OB_LAMP:
case OB_EMPTY:
case OB_ARMATURE:
base_objects.push_back(ob);
break;
}
}
}
// And now export the base objects:
for (int index = 0; index < base_objects.size(); index++) {
Object *ob = base_objects[index];
if (bc_is_marked(ob)) {
bc_remove_mark(ob);
writeNodes(ob, sce);
}
}
}
void SceneExporter::writeNodes(Object *ob, Scene *sce)
{
// Add associated armature first if available
bool armature_exported = false;
Object *ob_arm = bc_get_assigned_armature(ob);
if (ob_arm != NULL) {
armature_exported = bc_is_in_Export_set(this->export_settings->export_set, ob_arm);
if (armature_exported && bc_is_marked(ob_arm)) {
bc_remove_mark(ob_arm);
writeNodes(ob_arm, sce);
armature_exported = true;
}
}
COLLADASW::Node colladaNode(mSW);
colladaNode.setNodeId(translate_id(id_name(ob)));
colladaNode.setNodeName(translate_id(id_name(ob)));
colladaNode.setType(COLLADASW::Node::NODE);
colladaNode.start();
std::list<Object *> child_objects;
// list child objects
LinkNode *node;
for (node=this->export_settings->export_set; node; node=node->next) {
// cob - child object
Object *cob = (Object *)node->link;
if (cob->parent == ob) {
switch (cob->type) {
case OB_MESH:
case OB_CAMERA:
case OB_LAMP:
case OB_EMPTY:
case OB_ARMATURE:
if (bc_is_marked(cob))
child_objects.push_back(cob);
break;
}
}
}
if (ob->type == OB_MESH && armature_exported)
// for skinned mesh we write obmat in <bind_shape_matrix>
TransformWriter::add_node_transform_identity(colladaNode);
else
TransformWriter::add_node_transform_ob(colladaNode, ob);
// <instance_geometry>
if (ob->type == OB_MESH) {
bool instance_controller_created = false;
if (armature_exported) {
instance_controller_created = arm_exporter->add_instance_controller(ob);
}
if (!instance_controller_created) {
COLLADASW::InstanceGeometry instGeom(mSW);
instGeom.setUrl(COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_geometry_id(ob, this->export_settings->use_object_instantiation)));
InstanceWriter::add_material_bindings(instGeom.getBindMaterial(), ob, this->export_settings->active_uv_only);
instGeom.add();
}
}
// <instance_controller>
else if (ob->type == OB_ARMATURE) {
arm_exporter->add_armature_bones(ob, sce, this, child_objects);
}
// <instance_camera>
else if (ob->type == OB_CAMERA) {
COLLADASW::InstanceCamera instCam(mSW, COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_camera_id(ob)));
instCam.add();
}
// <instance_light>
else if (ob->type == OB_LAMP) {
COLLADASW::InstanceLight instLa(mSW, COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_light_id(ob)));
instLa.add();
}
// empty object
else if (ob->type == OB_EMPTY) { // TODO: handle groups (OB_DUPLIGROUP
if ((ob->transflag & OB_DUPLIGROUP) == OB_DUPLIGROUP && ob->dup_group) {
GroupObject *go = NULL;
Group *gr = ob->dup_group;
/* printf("group detected '%s'\n", gr->id.name+2); */
for (go = (GroupObject *)(gr->gobject.first); go; go = go->next) {
printf("\t%s\n", go->ob->id.name);
}
}
}
if (ob->type == OB_ARMATURE) {
colladaNode.end();
}
for (std::list<Object *>::iterator i = child_objects.begin(); i != child_objects.end(); ++i) {
if (bc_is_marked(*i)) {
bc_remove_mark(*i);
writeNodes(*i, sce);
}
}
if (ob->type != OB_ARMATURE) {
colladaNode.end();
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AbaqusSurfaceMeshWriter::execute()
{
int32_t err = 0;
setErrorCondition(err);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
// Make sure any directory path is also available as the user may have just typed
// in a path without actually creating the full path
QFileInfo fi(getOutputFile());
QDir parentPath = fi.path();
if(!parentPath.mkpath("."))
{
QString ss = QObject::tr("Error creating parent path '%1'").arg(parentPath.absolutePath());
setErrorCondition(-8005);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
// Store all the unique Spins
std::set<int32_t> uniqueSpins;
for (int64_t i = 0; i < triangleGeom->getNumberOfTris(); i++)
{
uniqueSpins.insert(m_SurfaceMeshFaceLabels[i * 2]);
uniqueSpins.insert(m_SurfaceMeshFaceLabels[i * 2 + 1]);
}
FILE* f = fopen(m_OutputFile.toLatin1().data(), "wb");
ScopedFileMonitor fileMonitor(f);
err = writeHeader(f, triangleGeom->getNumberOfVertices(), triangleGeom->getNumberOfTris(), uniqueSpins.size() - 1);
if(err < 0)
{
QString ss = QObject::tr("Error writing header for file '%1'").arg(m_OutputFile);
setErrorCondition(-8001);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
err = writeNodes(f);
if(err < 0)
{
QString ss = QObject::tr("Error writing nodes for file '%1'").arg(m_OutputFile);
setErrorCondition(-8002);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
err = writeTriangles(f);
if(err < 0)
{
QString ss = QObject::tr("Error writing triangles for file '%1'").arg(m_OutputFile);
setErrorCondition(-8003);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
err = writeFeatures(f);
if(err < 0)
{
QString ss = QObject::tr("Error writing Features for file '%1'").arg(m_OutputFile);
setErrorCondition(-8004);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
void SceneExporter::writeNodes(Object *ob, Scene *sce)
{
// Add associated armature first if available
bool armature_exported = false;
Object *ob_arm = bc_get_assigned_armature(ob);
if (ob_arm != NULL) {
armature_exported = bc_is_in_Export_set(this->export_settings->export_set, ob_arm);
if (armature_exported && bc_is_marked(ob_arm)) {
bc_remove_mark(ob_arm);
writeNodes(ob_arm, sce);
armature_exported = true;
}
}
COLLADASW::Node colladaNode(mSW);
colladaNode.setNodeId(translate_id(id_name(ob)));
colladaNode.setNodeName(translate_id(id_name(ob)));
colladaNode.setType(COLLADASW::Node::NODE);
colladaNode.start();
std::list<Object *> child_objects;
// list child objects
LinkNode *node;
for (node=this->export_settings->export_set; node; node=node->next) {
// cob - child object
Object *cob = (Object *)node->link;
if (cob->parent == ob) {
switch (cob->type) {
case OB_MESH:
case OB_CAMERA:
case OB_LAMP:
case OB_EMPTY:
case OB_ARMATURE:
if (bc_is_marked(cob))
child_objects.push_back(cob);
break;
}
}
}
if (ob->type == OB_MESH && armature_exported)
// for skinned mesh we write obmat in <bind_shape_matrix>
TransformWriter::add_node_transform_identity(colladaNode);
else {
TransformWriter::add_node_transform_ob(colladaNode, ob, this->transformation_type);
}
// <instance_geometry>
if (ob->type == OB_MESH) {
bool instance_controller_created = false;
if (armature_exported) {
instance_controller_created = arm_exporter->add_instance_controller(ob);
}
if (!instance_controller_created) {
COLLADASW::InstanceGeometry instGeom(mSW);
instGeom.setUrl(COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_geometry_id(ob, this->export_settings->use_object_instantiation)));
instGeom.setName(translate_id(id_name(ob)));
InstanceWriter::add_material_bindings(instGeom.getBindMaterial(), ob, this->export_settings->active_uv_only);
instGeom.add();
}
}
// <instance_controller>
else if (ob->type == OB_ARMATURE) {
arm_exporter->add_armature_bones(ob, sce, this, child_objects);
}
// <instance_camera>
else if (ob->type == OB_CAMERA) {
COLLADASW::InstanceCamera instCam(mSW, COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_camera_id(ob)));
instCam.add();
}
// <instance_light>
else if (ob->type == OB_LAMP) {
COLLADASW::InstanceLight instLa(mSW, COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_light_id(ob)));
instLa.add();
}
// empty object
else if (ob->type == OB_EMPTY) { // TODO: handle groups (OB_DUPLIGROUP
if ((ob->transflag & OB_DUPLIGROUP) == OB_DUPLIGROUP && ob->dup_group) {
GroupObject *go = NULL;
Group *gr = ob->dup_group;
/* printf("group detected '%s'\n", gr->id.name + 2); */
for (go = (GroupObject *)(gr->gobject.first); go; go = go->next) {
printf("\t%s\n", go->ob->id.name);
}
}
}
if (ob->type == OB_ARMATURE) {
colladaNode.end();
}
if (BLI_listbase_is_empty(&ob->constraints) == false) {
bConstraint *con = (bConstraint *) ob->constraints.first;
while (con) {
std::string con_name(translate_id(con->name));
std::string con_tag = con_name + "_constraint";
printf("%s\n", con_name.c_str());
printf("%s\n\n", con_tag.c_str());
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"type",con->type);
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"enforce",con->enforce);
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"flag",con->flag);
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"headtail",con->headtail);
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"lin_error",con->lin_error);
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"own_space",con->ownspace);
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"rot_error",con->rot_error);
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"tar_space",con->tarspace);
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"lin_error",con->lin_error);
//not ideal: add the target object name as another parameter.
//No real mapping in the .dae
//Need support for multiple target objects also.
const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
ListBase targets = {NULL, NULL};
if (cti && cti->get_constraint_targets) {
bConstraintTarget *ct;
Object *obtar;
cti->get_constraint_targets(con, &targets);
for (ct = (bConstraintTarget *)targets.first; ct; ct = ct->next) {
obtar = ct->tar;
std::string tar_id((obtar) ? id_name(obtar) : "");
colladaNode.addExtraTechniqueChildParameter("blender",con_tag,"target_id",tar_id);
}
if (cti->flush_constraint_targets)
cti->flush_constraint_targets(con, &targets, 1);
}
con = con->next;
}
}
for (std::list<Object *>::iterator i = child_objects.begin(); i != child_objects.end(); ++i) {
if (bc_is_marked(*i)) {
bc_remove_mark(*i);
writeNodes(*i, sce);
}
}
if (ob->type != OB_ARMATURE)
colladaNode.end();
}
