// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int32_t AbaqusSurfaceMeshWriter::writeNodes(FILE* f) { TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>(); float* nodes = triangleGeom->getVertexPointer(0); int64_t numNodes = triangleGeom->getNumberOfVertices(); int32_t err = 0; fprintf(f, "*Node,NSET=NALL\n"); //1, 72.520433763730, 70.306420652241, 100.000000000000 // Abaqus Starts number at 1 NOT 0(Zero). for (int64_t i = 1; i <= numNodes; ++i) { fprintf(f, "%lld, %0.6f, %0.6f, %0.6f\n", (long long int)i, nodes[(i - 1) * 3], nodes[(i - 1) * 3 + 1], nodes[(i - 1) * 3 + 2]); } return err; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void SurfaceMeshToNonconformalVtk::execute() { int err = 0; setErrorCondition(err); dataCheck(); if(getErrorCondition() < 0) { return; } DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName()); TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>(); float* nodes = triangleGeom->getVertexPointer(0); int64_t* triangles = triangleGeom->getTriPointer(0); qint64 numNodes = triangleGeom->getNumberOfVertices(); int64_t numTriangles = triangleGeom->getNumberOfTris(); // 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(getOutputVtkFile()); QDir parentPath = fi.path(); if(!parentPath.mkpath(".")) { QString ss = QObject::tr("Error creating parent path '%1'").arg(parentPath.absolutePath()); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } // Open the output VTK File for writing FILE* vtkFile = NULL; vtkFile = fopen(getOutputVtkFile().toLatin1().data(), "wb"); if (NULL == vtkFile) { QString ss = QObject::tr("Error creating file '%1'").arg(getOutputVtkFile()); setErrorCondition(-18542); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } ScopedFileMonitor vtkFileMonitor(vtkFile); notifyStatusMessage(getHumanLabel(), "Writing Vertex Data ...."); fprintf(vtkFile, "# vtk DataFile Version 2.0\n"); fprintf(vtkFile, "Data set from DREAM.3D Surface Meshing Module\n"); if (m_WriteBinaryFile) { fprintf(vtkFile, "BINARY\n"); } else { fprintf(vtkFile, "ASCII\n"); } fprintf(vtkFile, "DATASET POLYDATA\n"); int numberWrittenNodes = 0; for (int i = 0; i < numNodes; i++) { // Node& n = nodes[i]; // Get the current Node if (m_SurfaceMeshNodeType[i] > 0) { ++numberWrittenNodes; } else { qDebug() << "Node Type Invalid: " << i << "::" << (int)(m_SurfaceMeshNodeType[i]) ;} } fprintf(vtkFile, "POINTS %d float\n", numberWrittenNodes); float pos[3] = {0.0f, 0.0f, 0.0f}; size_t totalWritten = 0; // Write the POINTS data (Vertex) for (int i = 0; i < numNodes; i++) { if (m_SurfaceMeshNodeType[i] > 0) { pos[0] = static_cast<float>(nodes[i * 3]); pos[1] = static_cast<float>(nodes[i * 3 + 1]); pos[2] = static_cast<float>(nodes[i * 3 + 2]); if (m_WriteBinaryFile == true) { SIMPLib::Endian::FromSystemToBig::convert(pos[0]); SIMPLib::Endian::FromSystemToBig::convert(pos[1]); SIMPLib::Endian::FromSystemToBig::convert(pos[2]); totalWritten = fwrite(pos, sizeof(float), 3, vtkFile); if(totalWritten != 3) {} } else { fprintf(vtkFile, "%f %f %f\n", pos[0], pos[1], pos[2]); // Write the positions to the output file } } } // Write the triangle indices into the vtk File notifyStatusMessage(getHumanLabel(), "Writing Faces ...."); int tData[4]; // Store all the unique Spins QMap<int32_t, int32_t> featureTriangleCount; for (int i = 0; i < numTriangles; i++) { if (featureTriangleCount.find(m_SurfaceMeshFaceLabels[i * 2]) == featureTriangleCount.end()) { featureTriangleCount[m_SurfaceMeshFaceLabels[i * 2]] = 1; } else { featureTriangleCount[m_SurfaceMeshFaceLabels[i * 2]]++; } if (featureTriangleCount.find(m_SurfaceMeshFaceLabels[i * 2 + 1]) == featureTriangleCount.end()) { featureTriangleCount[m_SurfaceMeshFaceLabels[i * 2 + 1]] = 1; } else { featureTriangleCount[m_SurfaceMeshFaceLabels[i * 2 + 1]]++; } } // Write the POLYGONS fprintf(vtkFile, "\nPOLYGONS %lld %lld\n", (long long int)(numTriangles * 2), (long long int)(numTriangles * 2 * 4)); size_t totalCells = 0; // Loop over all the features for(QMap<int32_t, int32_t>::iterator featureIter = featureTriangleCount.begin(); featureIter != featureTriangleCount.end(); ++featureIter) { totalCells += featureIter.value(); } Q_ASSERT(totalCells == (size_t)(numTriangles * 2) ); // Loop over all the features for(QMap<int32_t, int32_t>::iterator featureIter = featureTriangleCount.begin(); featureIter != featureTriangleCount.end(); ++featureIter) { int32_t gid = featureIter.key(); // The current Feature Id int32_t numTriToWrite = featureIter.value(); // The number of triangles for this feature uint8_t doWrite = 0; // Loop over all the triangles looking for the current feature id // this is probably sub-optimal as if we have 1000 features we are going to loop 1000 times but this will use the // least amount of memory. We could run a filter to group the triangles by feature but then we would need an // additional amount of memory equal to 3X the memory used for the triangle list because every triangle will be listed // twice. We could get some slightly better performance if we buffered 4K worth of data then wrote out that data // in one chunk versus what we are doing here. for (int j = 0; j < numTriangles; j++) { doWrite = 0; if (m_SurfaceMeshFaceLabels[j * 2] == gid ) { doWrite = 1; } else if (m_SurfaceMeshFaceLabels[j * 2 + 1] == gid) { doWrite = 2; } // We need to flip the winding of the triangle if (doWrite == 0) { continue; } // Labels in the triangle did match the current feature id. if (doWrite == 1) { tData[0] = 3; // Push on the total number of entries for this entry tData[1] = triangles[j * 3]; tData[2] = triangles[j * 3 + 1]; tData[3] = triangles[j * 3 + 2]; } else { tData[0] = 3; // Push on the total number of entries for this entry tData[1] = triangles[j * 3 + 2]; tData[2] = triangles[j * 3 + 1]; tData[3] = triangles[j * 3]; } if (m_WriteBinaryFile == true) { SIMPLib::Endian::FromSystemToBig::convert(tData[0]); SIMPLib::Endian::FromSystemToBig::convert(tData[1]); // Index of Vertex 0 SIMPLib::Endian::FromSystemToBig::convert(tData[2]); // Index of Vertex 1 SIMPLib::Endian::FromSystemToBig::convert(tData[3]); // Index of Vertex 2 fwrite(tData, sizeof(int), 4, vtkFile); } else { fprintf(vtkFile, "3 %d %d %d\n", tData[1], tData[2], tData[3]); } numTriToWrite--; } if (numTriToWrite != 0) { qDebug() << "Not enough triangles written: " << gid << "::" << numTriToWrite << " Total Triangles to Write " << featureIter.value(); } } // Write the POINT_DATA section err = writePointData(vtkFile); // Write the CELL_DATA section err = writeCellData(vtkFile, featureTriangleCount); fprintf(vtkFile, "\n"); setErrorCondition(0); notifyStatusMessage(getHumanLabel(), "Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void SurfaceMeshToVtk::execute() { int err = 0; setErrorCondition(err); dataCheck(); if(getErrorCondition() < 0) { return; } setErrorCondition(0); DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName()); /* Place all your code to execute your filter here. */ TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>(); float* nodes = triangleGeom->getVertexPointer(0); int64_t* triangles = triangleGeom->getTriPointer(0); qint64 numNodes = triangleGeom->getNumberOfVertices(); int64_t numTriangles = triangleGeom->getNumberOfTris(); // 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(getOutputVtkFile()); QDir parentPath = fi.path(); if(!parentPath.mkpath(".")) { QString ss = QObject::tr("Error creating parent path '%1'").arg(parentPath.absolutePath()); notifyErrorMessage(getHumanLabel(), ss, -1); setErrorCondition(-1); return; } // Open the output VTK File for writing FILE* vtkFile = NULL; vtkFile = fopen(getOutputVtkFile().toLatin1().data(), "wb"); if (NULL == vtkFile) { QString ss = QObject::tr("Error creating file '%1'").arg(getOutputVtkFile()); notifyErrorMessage(getHumanLabel(), ss, -18542); setErrorCondition(-18542); return; } ScopedFileMonitor vtkFileMonitor(vtkFile); fprintf(vtkFile, "# vtk DataFile Version 2.0\n"); fprintf(vtkFile, "Data set from DREAM.3D Surface Meshing Module\n"); if (m_WriteBinaryFile) { fprintf(vtkFile, "BINARY\n"); } else { fprintf(vtkFile, "ASCII\n"); } fprintf(vtkFile, "DATASET POLYDATA\n"); int numberWrittenumNodes = 0; for (int i = 0; i < numNodes; i++) { // Node& n = nodes[i]; // Get the current Node if (m_SurfaceMeshNodeType[i] > 0) { ++numberWrittenumNodes; } } fprintf(vtkFile, "POINTS %d float\n", numberWrittenumNodes); float pos[3] = {0.0f, 0.0f, 0.0f}; size_t totalWritten = 0; // Write the POINTS data (Vertex) for (int i = 0; i < numNodes; i++) { if (m_SurfaceMeshNodeType[i] > 0) { pos[0] = static_cast<float>(nodes[i * 3]); pos[1] = static_cast<float>(nodes[i * 3 + 1]); pos[2] = static_cast<float>(nodes[i * 3 + 2]); if (m_WriteBinaryFile == true) { SIMPLib::Endian::FromSystemToBig::convert(pos[0]); SIMPLib::Endian::FromSystemToBig::convert(pos[1]); SIMPLib::Endian::FromSystemToBig::convert(pos[2]); totalWritten = fwrite(pos, sizeof(float), 3, vtkFile); if (totalWritten != sizeof(float) * 3) { } } else { fprintf(vtkFile, "%f %f %f\n", pos[0], pos[1], pos[2]); // Write the positions to the output file } } } int tData[4]; int triangleCount = numTriangles; // int tn1, tn2, tn3; if (false == m_WriteConformalMesh) { triangleCount = numTriangles * 2; } // Write the POLYGONS fprintf(vtkFile, "\nPOLYGONS %d %d\n", triangleCount, (triangleCount * 4)); for (int j = 0; j < numTriangles; j++) { // Triangle& t = triangles[j]; tData[1] = triangles[j * 3]; tData[2] = triangles[j * 3 + 1]; tData[3] = triangles[j * 3 + 2]; if (m_WriteBinaryFile == true) { tData[0] = 3; // Push on the total number of entries for this entry SIMPLib::Endian::FromSystemToBig::convert(tData[0]); SIMPLib::Endian::FromSystemToBig::convert(tData[1]); // Index of Vertex 0 SIMPLib::Endian::FromSystemToBig::convert(tData[2]); // Index of Vertex 1 SIMPLib::Endian::FromSystemToBig::convert(tData[3]); // Index of Vertex 2 fwrite(tData, sizeof(int), 4, vtkFile); if (false == m_WriteConformalMesh) { tData[0] = tData[1]; tData[1] = tData[3]; tData[3] = tData[0]; tData[0] = 3; SIMPLib::Endian::FromSystemToBig::convert(tData[0]); fwrite(tData, sizeof(int), 4, vtkFile); } } else { fprintf(vtkFile, "3 %d %d %d\n", tData[1], tData[2], tData[3]); if (false == m_WriteConformalMesh) { fprintf(vtkFile, "3 %d %d %d\n", tData[3], tData[2], tData[1]); } } } // Write the POINT_DATA section err = writePointData(vtkFile); // Write the CELL_DATA section err = writeCellData(vtkFile); fprintf(vtkFile, "\n"); setErrorCondition(0); notifyStatusMessage(getHumanLabel(), "Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ReadStlFile::eliminate_duplicate_nodes() { DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshDataContainerName); TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>(); float* vertex = triangleGeom->getVertexPointer(0); int64_t nNodes = triangleGeom->getNumberOfVertices(); int64_t* triangles = triangleGeom->getTriPointer(0); int64_t nTriangles = triangleGeom->getNumberOfTris(); float stepX = (m_maxXcoord - m_minXcoord) / 100.0f; float stepY = (m_maxYcoord - m_minYcoord) / 100.0f; float stepZ = (m_maxZcoord - m_minZcoord) / 100.0f; QVector<QVector<size_t> > nodesInBin(100 * 100 * 100); // determine (xyz) bin each node falls in - used to speed up node comparison int32_t bin = 0, xBin = 0, yBin = 0, zBin = 0; for (int64_t i = 0; i < nNodes; i++) { xBin = (vertex[i * 3] - m_minXcoord) / stepX; yBin = (vertex[i * 3 + 1] - m_minYcoord) / stepY; zBin = (vertex[i * 3 + 2] - m_minZcoord) / stepZ; if (xBin == 100) { xBin = 99; } if (yBin == 100) { yBin = 99; } if (zBin == 100) { zBin = 99; } bin = (zBin * 10000) + (yBin * 100) + xBin; nodesInBin[bin].push_back(i); } // Create array to hold unique node numbers Int64ArrayType::Pointer uniqueIdsPtr = Int64ArrayType::CreateArray(nNodes, "uniqueIds"); int64_t* uniqueIds = uniqueIdsPtr->getPointer(0); for (int64_t i = 0; i < nNodes; i++) { uniqueIds[i] = i; } #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS tbb::task_scheduler_init init; bool doParallel = true; #endif //Parallel algorithm to find duplicate nodes #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS if (doParallel == true) { tbb::parallel_for(tbb::blocked_range<size_t>(0, 100 * 100 * 100), FindUniqueIdsImpl(triangleGeom->getVertices(), nodesInBin, uniqueIds), tbb::auto_partitioner()); } else #endif { FindUniqueIdsImpl serial(triangleGeom->getVertices(), nodesInBin, uniqueIds); serial.convert(0, 100 * 100 * 100); } //renumber the unique nodes int64_t uniqueCount = 0; for (int64_t i = 0; i < nNodes; i++) { if(uniqueIds[i] == i) { uniqueIds[i] = uniqueCount; uniqueCount++; } else { uniqueIds[i] = uniqueIds[uniqueIds[i]]; } } // Move nodes to unique Id and then resize nodes array for (int64_t i = 0; i < nNodes; i++) { vertex[uniqueIds[i] * 3] = vertex[i * 3]; vertex[uniqueIds[i] * 3 + 1] = vertex[i * 3 + 1]; vertex[uniqueIds[i] * 3 + 2] = vertex[i * 3 + 2]; } triangleGeom->resizeVertexList(uniqueCount); // Update the triangle nodes to reflect the unique ids int64_t node1 = 0, node2 = 0, node3 = 0; for (int64_t i = 0; i < nTriangles; i++) { node1 = triangles[i * 3]; node2 = triangles[i * 3 + 1]; node3 = triangles[i * 3 + 2]; triangles[i * 3] = uniqueIds[node1]; triangles[i * 3 + 1] = uniqueIds[node2]; triangles[i * 3 + 2] = uniqueIds[node3]; } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ReadStlFile::readFile() { DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshDataContainerName); // Open File FILE* f = fopen(m_StlFilePath.toLatin1().data(), "rb"); if (NULL == f) { setErrorCondition(-1003); notifyErrorMessage(getHumanLabel(), "Error opening STL file", -1003); return; } // Read Header char h[80]; int32_t triCount = 0; fread(h, sizeof(int32_t), 20, f); fread(&triCount, sizeof(int32_t), 1, f); TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>(); triangleGeom->resizeTriList(triCount); triangleGeom->resizeVertexList(triCount * 3); float* nodes = triangleGeom->getVertexPointer(0); int64_t* triangles = triangleGeom->getTriPointer(0); // Resize the triangle attribute matrix to hold the normals and update the normals pointer QVector<size_t> tDims(1, triCount); sm->getAttributeMatrix(getFaceAttributeMatrixName())->resizeAttributeArrays(tDims); updateFaceInstancePointers(); // Read the triangles static const size_t k_StlElementCount = 12; float v[k_StlElementCount]; unsigned short attr; for (int32_t t = 0; t < triCount; ++t) { fread(reinterpret_cast<void*>(v), sizeof(float), k_StlElementCount, f); fread(reinterpret_cast<void*>(&attr), sizeof(unsigned short), 1, f); if (attr > 0) { std::vector<unsigned char> buffer(attr); // Allocate a buffer for the STL attribute data to be placed into fread( reinterpret_cast<void*>(&(buffer.front())), attr, 1, f); // Read the bytes into the buffer so that we can skip it. } if(v[3] < m_minXcoord) { m_minXcoord = v[3]; } if(v[3] > m_maxXcoord) { m_maxXcoord = v[3]; } if(v[4] < m_minYcoord) { m_minYcoord = v[4]; } if(v[4] > m_maxYcoord) { m_maxYcoord = v[4]; } if(v[5] < m_minZcoord) { m_minZcoord = v[5]; } if(v[5] > m_maxZcoord) { m_maxZcoord = v[5]; } if(v[6] < m_minXcoord) { m_minXcoord = v[6]; } if(v[6] > m_maxXcoord) { m_maxXcoord = v[6]; } if(v[7] < m_minYcoord) { m_minYcoord = v[7]; } if(v[7] > m_maxYcoord) { m_maxYcoord = v[7]; } if(v[8] < m_minZcoord) { m_minZcoord = v[8]; } if(v[8] > m_maxZcoord) { m_maxZcoord = v[8]; } if(v[9] < m_minXcoord) { m_minXcoord = v[9]; } if(v[9] > m_maxXcoord) { m_maxXcoord = v[9]; } if(v[10] < m_minYcoord) { m_minYcoord = v[10]; } if(v[10] > m_maxYcoord) { m_maxYcoord = v[10]; } if(v[11] < m_minZcoord) { m_minZcoord = v[11]; } if(v[11] > m_maxZcoord) { m_maxZcoord = v[11]; } m_FaceNormals[3 * t + 0] = v[0]; m_FaceNormals[3 * t + 1] = v[1]; m_FaceNormals[3 * t + 2] = v[2]; nodes[3 * (3 * t + 0) + 0] = v[3]; nodes[3 * (3 * t + 0) + 1] = v[4]; nodes[3 * (3 * t + 0) + 2] = v[5]; nodes[3 * (3 * t + 1) + 0] = v[6]; nodes[3 * (3 * t + 1) + 1] = v[7]; nodes[3 * (3 * t + 1) + 2] = v[8]; nodes[3 * (3 * t + 2) + 0] = v[9]; nodes[3 * (3 * t + 2) + 1] = v[10]; nodes[3 * (3 * t + 2) + 2] = v[11]; triangles[t * 3] = 3 * t + 0; triangles[t * 3 + 1] = 3 * t + 1; triangles[t * 3 + 2] = 3 * t + 2; } return; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WriteTriangleGeometry::execute() { int err = 0; setErrorCondition(err); dataCheck(); if(getErrorCondition() < 0) { return; } DataContainer::Pointer dataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerSelection()); TriangleGeom::Pointer triangleGeom = dataContainer->getGeometryAs<TriangleGeom>(); QString geometryType = triangleGeom->getGeometryTypeAsString(); float* nodes = triangleGeom->getVertexPointer(0); int64_t* triangles = triangleGeom->getTriPointer(0); qint64 numNodes = triangleGeom->getNumberOfVertices(); qint64 maxNodeId = numNodes - 1; int64_t numTriangles = triangleGeom->getNumberOfTris(); // ++++++++++++++ Write the Nodes File +++++++++++++++++++++++++++++++++++++++++++ // Make sure any directory path is also available as the user may have just typed // in a path without actually creating the full path notifyStatusMessage(getHumanLabel(), "Writing Nodes Text File"); QFileInfo fi(getOutputNodesFile()); QDir parentPath = fi.path(); if(!parentPath.mkpath(".")) { QString ss = QObject::tr("Error creating parent path '%1'").arg(parentPath.absolutePath()); notifyErrorMessage(getHumanLabel(), ss, -1); setErrorCondition(-1); return; } FILE* nodesFile = NULL; nodesFile = fopen(getOutputNodesFile().toLatin1().data(), "wb"); if (NULL == nodesFile) { setErrorCondition(-100); notifyErrorMessage(getHumanLabel(), "Error opening Nodes file for writing", -100); return; } fprintf(nodesFile, "# All lines starting with '#' are comments\n"); fprintf(nodesFile, "# DREAM.3D Nodes file\n"); fprintf(nodesFile, "# DREAM.3D Version %s\n", SIMPLib::Version::Complete().toLatin1().constData()); fprintf(nodesFile, "# Node Data is X Y Z space delimited.\n"); fprintf(nodesFile, "Node Count: %lld\n", numNodes); for (int i = 0; i < numNodes; i++) { fprintf(nodesFile, "%8.5f %8.5f %8.5f\n", nodes[i * 3], nodes[i * 3 + 1], nodes[i * 3 + 2]); } fclose(nodesFile); // ++++++++++++++ Write the Triangles File +++++++++++++++++++++++++++++++++++++++++++ notifyStatusMessage(getHumanLabel(), "Writing Triangles Text File"); QFileInfo triFI(getOutputTrianglesFile()); parentPath = triFI.path(); if(!parentPath.mkpath(".")) { QString ss = QObject::tr("Error creating parent path '%1'").arg(parentPath.absolutePath()); notifyErrorMessage(getHumanLabel(), ss, -1); setErrorCondition(-1); return; } FILE* triFile = fopen(getOutputTrianglesFile().toLatin1().data(), "wb"); if (NULL == triFile) { setErrorCondition(-100); notifyErrorMessage(getHumanLabel(), "Error opening Triangles file for writing", -100); return; } fprintf(triFile, "# All lines starting with '#' are comments\n"); fprintf(triFile, "# DREAM.3D Triangle file\n"); fprintf(triFile, "# DREAM.3D Version %s\n", SIMPLib::Version::Complete().toLatin1().constData()); fprintf(triFile, "# Each Triangle consists of 3 Node Ids.\n"); fprintf(triFile, "# NODE IDs START AT 0.\n"); fprintf(triFile, "Geometry Type: %s\n", geometryType.toLatin1().constData()); fprintf(triFile, "Node Count: %lld\n", numNodes); fprintf(triFile, "Max Node Id: %lld\n", maxNodeId ); fprintf(triFile, "Triangle Count: %lld\n", (long long int)(numTriangles)); int n1, n2, n3; for (int64_t j = 0; j < numTriangles; ++j) { n1 = triangles[j * 3]; n2 = triangles[j * 3 + 1]; n3 = triangles[j * 3 + 2]; fprintf(triFile, "%d %d %d\n", n1, n2, n3); } fclose(triFile); /* Let the GUI know we are done with this filter */ notifyStatusMessage(getHumanLabel(), "Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WriteStlFile::execute() { int32_t err = 0; setErrorCondition(0); dataCheck(); 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 QDir stlDir(getOutputStlDirectory()); if (!stlDir.mkpath(".")) { QString ss = QObject::tr("Error creating parent path '%1'").arg(getOutputStlDirectory()); notifyErrorMessage(getHumanLabel(), ss, -1); setErrorCondition(-1); return; } TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>(); float* nodes = triangleGeom->getVertexPointer(0); int64_t* triangles = triangleGeom->getTriPointer(0); int64_t nTriangles = triangleGeom->getNumberOfTris(); if (nTriangles > std::numeric_limits<int32_t>::max()) { QString ss = QObject::tr("The number of triangles is %1, but the STL specification only supports triangle counts up to %2").arg(nTriangles).arg(std::numeric_limits<int32_t>::max()); notifyErrorMessage(getHumanLabel(), ss, -1); setErrorCondition(-1); return; } // Store all the unique Spins QMap<int32_t, int32_t> uniqueGrainIdtoPhase; if (m_GroupByPhase == true) { for (int64_t i = 0; i < nTriangles; i++) { uniqueGrainIdtoPhase.insert(m_SurfaceMeshFaceLabels[i * 2], m_SurfaceMeshFacePhases[i * 2]); uniqueGrainIdtoPhase.insert(m_SurfaceMeshFaceLabels[i * 2 + 1], m_SurfaceMeshFacePhases[i * 2 + 1]); } } else { for (int64_t i = 0; i < nTriangles; i++) { uniqueGrainIdtoPhase.insert(m_SurfaceMeshFaceLabels[i * 2], 0); uniqueGrainIdtoPhase.insert(m_SurfaceMeshFaceLabels[i * 2 + 1], 0); } } unsigned char data[50]; float* normal = (float*)data; float* vert1 = (float*)(data + 12); float* vert2 = (float*)(data + 24); float* vert3 = (float*)(data + 36); uint16_t* attrByteCount = (uint16_t*)(data + 48); *attrByteCount = 0; size_t totalWritten = 0; float u[3] = { 0.0f, 0.0f, 0.0f }, w[3] = { 0.0f, 0.0f, 0.0f }; float length = 0.0f; int32_t spin = 0; int32_t triCount = 0; //Loop over the unique Spins for (QMap<int32_t, int32_t>::iterator spinIter = uniqueGrainIdtoPhase.begin(); spinIter != uniqueGrainIdtoPhase.end(); ++spinIter ) { spin = spinIter.key(); // Generate the output file name QString filename = getOutputStlDirectory() + "/" + getOutputStlPrefix(); if (m_GroupByPhase == true) { filename = filename + QString("Ensemble_") + QString::number(spinIter.value()) + QString("_"); } filename = filename + QString("Feature_") + QString::number(spin) + ".stl"; FILE* f = fopen(filename.toLatin1().data(), "wb"); { QString ss = QObject::tr("Writing STL for Feature Id %1").arg(spin); notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss); } QString header = "DREAM3D Generated For Feature ID " + QString::number(spin); if (m_GroupByPhase == true) { header = header + " Phase " + QString::number(spinIter.value()); } err = writeHeader(f, header, 0); if (err < 0) { } triCount = 0; // Reset this to Zero. Increment for every triangle written // Loop over all the triangles for this spin for (int64_t t = 0; t < nTriangles; ++t) { // Get the true indices of the 3 nodes int64_t nId0 = triangles[t * 3]; int64_t nId1 = triangles[t * 3 + 1]; int64_t nId2 = triangles[t * 3 + 2]; vert1[0] = static_cast<float>(nodes[nId0 * 3]); vert1[1] = static_cast<float>(nodes[nId0 * 3 + 1]); vert1[2] = static_cast<float>(nodes[nId0 * 3 + 2]); if (m_SurfaceMeshFaceLabels[t * 2] == spin) { //winding = 0; // 0 = Write it using forward spin } else if (m_SurfaceMeshFaceLabels[t * 2 + 1] == spin) { //winding = 1; // Write it using backward spin // Switch the 2 node indices int64_t temp = nId1; nId1 = nId2; nId2 = temp; } else { continue; // We do not match either spin so move to the next triangle } vert2[0] = static_cast<float>(nodes[nId1 * 3]); vert2[1] = static_cast<float>(nodes[nId1 * 3 + 1]); vert2[2] = static_cast<float>(nodes[nId1 * 3 + 2]); vert3[0] = static_cast<float>(nodes[nId2 * 3]); vert3[1] = static_cast<float>(nodes[nId2 * 3 + 1]); vert3[2] = static_cast<float>(nodes[nId2 * 3 + 2]); // Compute the normal u[0] = vert2[0] - vert1[0]; u[1] = vert2[1] - vert1[1]; u[2] = vert2[2] - vert1[2]; w[0] = vert3[0] - vert1[0]; w[1] = vert3[1] - vert1[1]; w[2] = vert3[2] - vert1[2]; normal[0] = u[1] * w[2] - u[2] * w[1]; normal[1] = u[2] * w[0] - u[0] * w[2]; normal[2] = u[0] * w[1] - u[1] * w[0]; length = sqrtf(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2]); normal[0] = normal[0] / length; normal[1] = normal[1] / length; normal[2] = normal[2] / length; totalWritten = fwrite(data, 1, 50, f); if (totalWritten != 50) { QString ss = QObject::tr("Error Writing STL File. Not enough elements written for Feature Id %1. Wrote %2 of 50.").arg(spin).arg(totalWritten); notifyErrorMessage(getHumanLabel(), ss, -1201); } triCount++; } fclose(f); err = writeNumTrianglesToFile(filename, triCount); } setErrorCondition(0); notifyStatusMessage(getHumanLabel(), "Complete"); return; }