// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AbaqusSurfaceMeshWriter::dataCheck()
{
setErrorCondition(0);
if (m_OutputFile.isEmpty() == true)
{
setErrorCondition(-1003);
notifyErrorMessage(getHumanLabel(), "The output file must be set", getErrorCondition());
}
QFileInfo fi(m_OutputFile);
QDir parentPath = fi.path();
if (parentPath.exists() == false)
{
QString ss = QObject::tr( "The directory path for the output file does not exist. DREAM.3D will attempt to create this path during execution of the filter");
notifyWarningMessage(getHumanLabel(), ss, -1);
}
QVector<IDataArray::Pointer> dataArrays;
TriangleGeom::Pointer triangles = getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
if(getErrorCondition() >= 0) { dataArrays.push_back(triangles->getTriangles()); }
QVector<size_t> cDims(1, 2);
m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFaceLabelsPtr.lock()); }
getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, dataArrays);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void LaplacianSmoothing::dataCheck()
{
TriangleGeom::Pointer triangles = getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
QVector<IDataArray::Pointer> faceDataArrays;
QVector<IDataArray::Pointer> nodeDataArrays;
if(getErrorCondition() >= 0) { faceDataArrays.push_back(triangles->getTriangles()); nodeDataArrays.push_back(triangles->getVertices()); }
QVector<size_t> cDims(1, 1);
m_SurfaceMeshNodeTypePtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int8_t>, AbstractFilter>(this, getSurfaceMeshNodeTypeArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshNodeTypePtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshNodeType = m_SurfaceMeshNodeTypePtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() >= 0) { nodeDataArrays.push_back(m_SurfaceMeshNodeTypePtr.lock()); }
cDims[0] = 2;
m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() >= 0) { faceDataArrays.push_back(m_SurfaceMeshFaceLabelsPtr.lock()); }
getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, faceDataArrays);
getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, nodeDataArrays);
setSurfaceDataContainerName(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateFaceMisorientationColoring::dataCheckSurfaceMesh()
{
setErrorCondition(0);
DataArrayPath tempPath;
TriangleGeom::Pointer triangles = getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName());
QVector<IDataArray::Pointer> dataArrays;
if(getErrorCondition() >= 0) { dataArrays.push_back(triangles->getTriangles()); }
QVector<size_t> cDims(1, 2);
m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFaceLabelsPtr.lock()); }
cDims[0] = 3;
tempPath.update(m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName(), m_SurfaceMeshFaceLabelsArrayPath.getAttributeMatrixName(), getSurfaceMeshFaceMisorientationColorsArrayName() );
m_SurfaceMeshFaceMisorientationColorsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, tempPath, 0, cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFaceMisorientationColorsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFaceMisorientationColors = m_SurfaceMeshFaceMisorientationColorsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, dataArrays);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WriteStlFile::dataCheck()
{
setErrorCondition(0);
TriangleGeom::Pointer triangles = getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
QVector<IDataArray::Pointer> dataArrays;
if(getErrorCondition() >= 0) { dataArrays.push_back(triangles->getTriangles()); }
if (m_OutputStlDirectory.isEmpty() == true)
{
setErrorCondition(-1003);
notifyErrorMessage(getHumanLabel(), "The output directory must be set", -1003);
}
QVector<size_t> cDims(1, 2);
m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFaceLabelsPtr.lock()); }
if (m_GroupByPhase == true)
{
m_SurfaceMeshFacePhasesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFacePhasesArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFacePhasesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFacePhases = m_SurfaceMeshFacePhasesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFacePhasesPtr.lock()); }
}
getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, dataArrays);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReverseTriangleWinding::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) {
return;
}
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceDataContainerName());
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
bool doParallel = true;
#endif
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, triangleGeom->getNumberOfTris()),
ReverseWindingImpl(triangleGeom->getTriangles()), tbb::auto_partitioner());
}
else
#endif
{
ReverseWindingImpl serial(triangleGeom->getTriangles());
serial.generate(0, triangleGeom->getNumberOfTris());
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
void writeCellScalarData(DataContainer::Pointer dc, const QString& faceAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, FILE* vtkFile, QMap<int32_t, int32_t>& featureIds, int32_t* m_SurfaceMeshFaceLabels)
{
TriangleGeom::Pointer triangleGeom = dc->getGeometryAs<TriangleGeom>();
int64_t numTriangles = triangleGeom->getNumberOfTris();
IDataArray::Pointer data = dc->getAttributeMatrix(faceAttributeMatrixName)->getAttributeArray(dataName);
QString ss;
if (NULL != data.get())
{
int32_t totalCellsWritten = 0;
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "SCALARS %s %s 1\n", dataName.toLatin1().data(), dataType.toLatin1().data());
fprintf(vtkFile, "LOOKUP_TABLE default\n");
// Loop over all the features
for(QMap<int32_t, int32_t>::iterator featureIter = featureIds.begin(); featureIter != featureIds.end(); ++featureIter)
{
int32_t gid = featureIter.key(); // The current Feature Id
size_t size = featureIter.value(); // The number of triangles for this feature id
std::vector<T> buffer(size, 0);
totalCellsWritten += size;
size_t index = 0;
for (int j = 0; j < numTriangles; j++)
{
if (m_SurfaceMeshFaceLabels[j * 2] != gid && m_SurfaceMeshFaceLabels[j * 2 + 1] != gid) { continue; }
// Get the data
T s0 = static_cast<T>(m[j]);
if (m_SurfaceMeshFaceLabels[j * 2 + 1] == gid)
{ s0 = s0 * -1; }
// Write the values to the buffer after an Endian swap.
if(writeBinaryData == true)
{
SIMPLib::Endian::FromSystemToBig::convert(s0);
buffer[index] = s0;
++index;
}
else
{
ss = QString::number(s0);
fprintf(vtkFile, "%s\n", ss.toLatin1().data());
}
}
// Write the Buffer
if(writeBinaryData == true)
{
fwrite(&(buffer.front()), sizeof(T), size, vtkFile);
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 SampleSurfaceMesh::dataCheck()
{
TriangleGeom::Pointer triangles = getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
if(getErrorCondition() < 0) { return; }
QVector<IDataArray::Pointer> dataArrays;
if(getErrorCondition() >= 0) { dataArrays.push_back(triangles->getTriangles()); }
QVector<size_t> cDims(1, 2);
m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFaceLabelsPtr.lock()); }
getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, dataArrays);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void TriangleCentroidFilter::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceMeshTriangleCentroidsArrayPath().getDataContainerName());
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
// No check because datacheck() made sure we can do the next line.
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, triangleGeom->getNumberOfTris()),
CalculateCentroidsImpl(triangleGeom->getVertices(), triangleGeom->getTriangles(), m_SurfaceMeshTriangleCentroids), tbb::auto_partitioner());
}
else
#endif
{
CalculateCentroidsImpl serial(triangleGeom->getVertices(), triangleGeom->getTriangles(), m_SurfaceMeshTriangleCentroids);
serial.generate(0, triangleGeom->getNumberOfTris());
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int32_t AbaqusSurfaceMeshWriter::writeTriangles(FILE* f)
{
int32_t err = 0;
TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>();
int64_t numTri = triangleGeom->getNumberOfTris();
int64_t* triangles = triangleGeom->getTriPointer(0);
fprintf(f, "*ELEMENT, TYPE=%s\n", TRI_ELEMENT_TYPE);
for (int64_t i = 1; i <= numTri; ++i)
{
// When we get the node index, add 1 to it because Abaqus number is 1 based.
int64_t nId0 = triangles[(i - 1) * 3] + 1;
int64_t nId1 = triangles[(i - 1) * 3 + 1] + 1;
int64_t nId2 = triangles[(i - 1) * 3 + 2] + 1;
fprintf(f, "%lld, %lld, %lld, %lld\n", (long long int)i, (long long int)nId0, (long long int)nId1, (long long int)nId2);
}
return err;
}
void writeCellVectorData(DataContainer::Pointer dc, const QString& faceAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, const QString& vtkAttributeType,
FILE* vtkFile, QMap<int32_t, int32_t>& featureIds)
{
TriangleGeom::Pointer triangleGeom = dc->getGeometryAs<TriangleGeom>();
int64_t numTriangles = triangleGeom->getNumberOfTris();
IDataArray::Pointer data = dc->getAttributeMatrix(faceAttributeMatrixName)->getAttributeArray(dataName);
QString ss;
if (NULL != data.get())
{
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "%s %s %s\n", vtkAttributeType.toLatin1().data(), dataName.toLatin1().data(), dataType.toLatin1().data());
for(int i = 0; i < numTriangles; ++i)
{
T s0 = 0x00;
T s1 = 0x00;
T s2 = 0x00;
if(writeBinaryData == true)
{
s0 = static_cast<T>(m[i * 3 + 0]);
s1 = static_cast<T>(m[i * 3 + 1]);
s2 = static_cast<T>(m[i * 3 + 2]);
SIMPLib::Endian::FromSystemToBig::convert(s0);
SIMPLib::Endian::FromSystemToBig::convert(s1);
SIMPLib::Endian::FromSystemToBig::convert(s2);
fwrite(&s0, sizeof(T), 1, vtkFile);
fwrite(&s1, sizeof(T), 1, vtkFile);
fwrite(&s2, sizeof(T), 1, vtkFile);
}
else
{
ss << m[i * 3 + 0] << " " << m[i * 3 + 1] << " " << m[i * 3 + 2] << " ";
fprintf(vtkFile, "%s ", ss.toLatin1().data());
if (i % 25 == 0) { fprintf(vtkFile, "\n"); }
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InsertAtoms::dataCheck()
{
setErrorCondition(0);
DataArrayPath tempPath;
TriangleGeom::Pointer triangles = getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
QVector<IDataArray::Pointer> dataArrays;
if(getErrorCondition() >= 0) { dataArrays.push_back(triangles->getTriangles()); }
DataContainer::Pointer v = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getVertexDataContainerName());
if(getErrorCondition() < 0) { return; }
VertexGeom::Pointer vertices = VertexGeom::CreateGeometry(0, DREAM3D::Geometry::VertexGeometry);
v->setGeometry(vertices);
QVector<size_t> tDims(1, 0);
AttributeMatrix::Pointer vertexAttrMat = v->createNonPrereqAttributeMatrix<AbstractFilter>(this, getVertexAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Vertex);
if(getErrorCondition() < 0 || NULL == vertexAttrMat.get()) { return; }
QVector<size_t> cDims(1, 2);
m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if(getErrorCondition() >= 0) { dataArrays.push_back(m_SurfaceMeshFaceLabelsPtr.lock()); }
cDims[0] = 4;
m_AvgQuatsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getAvgQuatsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_AvgQuatsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_AvgQuats = m_AvgQuatsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
cDims[0] = 1;
tempPath.update(getVertexDataContainerName(), getVertexAttributeMatrixName(), getAtomFeatureLabelsArrayName() );
m_AtomFeatureLabelsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, -301, cDims); /* Assigns the shared_ptr<>(this, tempPath, -301, dims); Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_AtomFeatureLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_AtomFeatureLabels = m_AtomFeatureLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
getDataContainerArray()->validateNumberOfTuples<AbstractFilter>(this, dataArrays);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SurfaceMeshToNonconformalVtk::dataCheck()
{
setErrorCondition(0);
QString ss;
if (m_OutputVtkFile.isEmpty() == true)
{
setErrorCondition(-1003);
notifyErrorMessage(getHumanLabel(), "Vtk Output file is Not set correctly", -1003);
}
DataContainer::Pointer sm = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName(), false);
if(getErrorCondition() < 0) { return; }
TriangleGeom::Pointer triangles = sm->getPrereqGeometry<TriangleGeom, AbstractFilter>(this);
if(getErrorCondition() < 0) { return; }
// We MUST have Nodes
if (NULL == triangles->getVertices().get())
{
setErrorCondition(-386);
notifyErrorMessage(getHumanLabel(), "DataContainer Geometry missing Vertices", getErrorCondition());
}
// We MUST have Triangles defined also.
if (NULL == triangles->getTriangles().get())
{
setErrorCondition(-387);
notifyErrorMessage(getHumanLabel(), "DataContainer Geometry missing Triangles", getErrorCondition());
}
QVector<size_t> dims(1, 2);
m_SurfaceMeshFaceLabelsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getSurfaceMeshFaceLabelsArrayPath(), dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshFaceLabelsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshFaceLabels = m_SurfaceMeshFaceLabelsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 1;
m_SurfaceMeshNodeTypePtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int8_t>, AbstractFilter>(this, getSurfaceMeshNodeTypeArrayPath(), dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceMeshNodeTypePtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceMeshNodeType = m_SurfaceMeshNodeTypePtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
IGeometry::Pointer TriangleGeom::deepCopy()
{
TriangleGeom::Pointer triCopy = TriangleGeom::CreateGeometry(getTriangles(), getVertices(), getName());
triCopy->setEdges(getEdges());
triCopy->setUnsharedEdges(getUnsharedEdges());
triCopy->setElementsContainingVert(getElementsContainingVert());
triCopy->setElementNeighbors(getElementNeighbors());
triCopy->setElementCentroids(getElementCentroids());
triCopy->setSpatialDimensionality(getSpatialDimensionality());
return triCopy;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WriteTriangleGeometry::dataCheck()
{
setErrorCondition(0);
if(true == m_OutputNodesFile.isEmpty())
{
setErrorCondition(-380);
notifyErrorMessage(getHumanLabel(), "The output Nodes file needs to be set", getErrorCondition());
}
if(true == m_OutputTrianglesFile.isEmpty())
{
setErrorCondition(-382);
notifyErrorMessage(getHumanLabel(), "The output Triangles file needs to be set", getErrorCondition());
}
DataContainer::Pointer dataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerSelection());
if(getErrorCondition() < 0) { return; }
TriangleGeom::Pointer triangles = dataContainer->getPrereqGeometry<TriangleGeom, AbstractFilter>(this);
if(getErrorCondition() < 0) { return; }
// We MUST have Nodes
if (NULL == triangles->getVertices().get())
{
setErrorCondition(-386);
notifyErrorMessage(getHumanLabel(), "DataContainer Geometry missing Vertices", getErrorCondition());
}
// We MUST have Triangles defined also.
if (NULL == triangles->getTriangles().get())
{
setErrorCondition(-387);
notifyErrorMessage(getHumanLabel(), "DataContainer Geometry missing Triangles", getErrorCondition());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 writeCellNormalData(DataContainer::Pointer dc, const QString& faceAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, FILE* vtkFile, QMap<int32_t, int32_t>& featureIds, int32_t* m_SurfaceMeshFaceLabels)
{
TriangleGeom::Pointer triangleGeom = dc->getGeometryAs<TriangleGeom>();
int64_t numTriangles = triangleGeom->getNumberOfTris();
IDataArray::Pointer data = dc->getAttributeMatrix(faceAttributeMatrixName)->getAttributeArray(dataName);
QString buf;
QTextStream ss(&buf);
if (NULL != data.get())
{
int32_t totalCellsWritten = 0;
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "NORMALS %s %s\n", dataName.toLatin1().data(), dataType.toLatin1().data());
// Loop over all the features
for(QMap<int32_t, int32_t>::iterator featureIter = featureIds.begin(); featureIter != featureIds.end(); ++featureIter)
{
int32_t gid = featureIter.key(); // The current Feature Id
size_t size = featureIter.value(); // The number of triangles for this feature id
std::vector<T> buffer(size * 3, 0);
totalCellsWritten += size * 3;
size_t index = 0;
for (int j = 0; j < numTriangles; j++)
{
if (m_SurfaceMeshFaceLabels[j * 2] != gid && m_SurfaceMeshFaceLabels[j * 2 + 1] != gid) { continue; }
// Get the data
T s0 = static_cast<T>(m[j * 3 + 0]);
T s1 = static_cast<T>(m[j * 3 + 1]);
T s2 = static_cast<T>(m[j * 3 + 2]);
// Flip the normal if needed because the current feature id is assigned to the triangle.labels[1]
if (m_SurfaceMeshFaceLabels[j * 2 + 1] == gid )
{
s0 *= -1.0;
s1 *= -1.0;
s2 *= -1.0;
}
// Write the values to the buffer after an Endian swap.
if(writeBinaryData == true)
{
SIMPLib::Endian::FromSystemToBig::convert(s0);
buffer[index] = s0;
++index;
SIMPLib::Endian::FromSystemToBig::convert(s1);
buffer[index] = s1;
++index;
SIMPLib::Endian::FromSystemToBig::convert(s2);
buffer[index] = s2;
++index;
}
else
{
ss << s0 << " " << s1 << " " << s2;
fprintf(vtkFile, "%s\n", buf.toLatin1().data());
buf.clear();
}
}
// Write the Buffer
if(writeBinaryData == true)
{
fwrite(&(buffer.front()), sizeof(T), size * 3, vtkFile);
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FeatureFaceCurvatureFilter::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
// Get our Reference counted Array of Face Structures
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
// Just to double check we have everything.
int64_t numTriangles = triangleGeom->getNumberOfTris();
// Make sure the Face Connectivity is created because the FindNRing algorithm needs this and will
// assert if the data is NOT in the SurfaceMesh Data Container
ElementDynamicList::Pointer vertLinks = triangleGeom->getElementsContainingVert();
if (NULL == vertLinks.get())
{
triangleGeom->findElementsContainingVert();
}
// get the QMap from the SharedFeatureFaces filter
SharedFeatureFaces_t sharedFeatureFaces;
int32_t maxFaceId = 0;
for (int64_t t = 0; t < numTriangles; ++t)
{
if (m_SurfaceMeshFeatureFaceIds[t] > maxFaceId) { maxFaceId = m_SurfaceMeshFeatureFaceIds[t]; }
}
std::vector<int32_t> faceSizes(maxFaceId + 1, 0);
// Loop through all the Triangles and assign each one to a unique Feature Face Id.
for (int64_t t = 0; t < numTriangles; ++t)
{
faceSizes[m_SurfaceMeshFeatureFaceIds[t]]++;
}
// Allocate all the vectors that we need
for (size_t iter = 0; iter < faceSizes.size(); ++iter)
{
FaceIds_t v;
v.reserve(faceSizes[iter]);
sharedFeatureFaces[iter] = v;
}
// Loop through all the Triangles and assign each one to a unique Feature Face Id.
for(int64_t t = 0; t < numTriangles; ++t)
{
sharedFeatureFaces[m_SurfaceMeshFeatureFaceIds[t]].push_back(t);
}
m_TotalFeatureFaces = sharedFeatureFaces.size();
m_CompletedFeatureFaces = 0;
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_group* g = new tbb::task_group;
#else
#endif
// typedef here for conveneince
typedef SharedFeatureFaces_t::iterator SharedFeatureFaceIterator_t;
for(SharedFeatureFaceIterator_t iter = sharedFeatureFaces.begin(); iter != sharedFeatureFaces.end(); ++iter)
{
QString ss = QObject::tr("Working on Face Id %1/%2").arg((*iter).first).arg(maxFaceId);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
FaceIds_t& triangleIds = (*iter).second;
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
g->run(CalculateTriangleGroupCurvatures(m_NRing, triangleIds, m_UseNormalsForCurveFitting,
m_SurfaceMeshPrincipalCurvature1sPtr.lock(), m_SurfaceMeshPrincipalCurvature2sPtr.lock(),
m_SurfaceMeshPrincipalDirection1sPtr.lock(), m_SurfaceMeshPrincipalDirection2sPtr.lock(),
m_SurfaceMeshGaussianCurvaturesPtr.lock(), m_SurfaceMeshMeanCurvaturesPtr.lock(), triangleGeom,
m_SurfaceMeshFaceLabelsPtr.lock(),
m_SurfaceMeshFaceNormalsPtr.lock(),
m_SurfaceMeshTriangleCentroidsPtr.lock(),
this ) );
}
else
#endif
{
CalculateTriangleGroupCurvatures curvature(m_NRing, triangleIds, m_UseNormalsForCurveFitting,
m_SurfaceMeshPrincipalCurvature1sPtr.lock(), m_SurfaceMeshPrincipalCurvature2sPtr.lock(),
m_SurfaceMeshPrincipalDirection1sPtr.lock(), m_SurfaceMeshPrincipalDirection2sPtr.lock(),
m_SurfaceMeshGaussianCurvaturesPtr.lock(), m_SurfaceMeshMeanCurvaturesPtr.lock(), triangleGeom,
m_SurfaceMeshFaceLabelsPtr.lock(),
m_SurfaceMeshFaceNormalsPtr.lock(),
m_SurfaceMeshTriangleCentroidsPtr.lock(),
this );
curvature();
}
}
// *********************** END END END END END END ********************************************************************
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
g->wait(); // Wait for all the threads to complete before moving on.
delete g;
#endif
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int SurfaceMeshToNonconformalVtk::writePointData(FILE* vtkFile)
{
int err = 0;
if (NULL == vtkFile)
{
return -1;
}
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshNodeTypeArrayPath.getDataContainerName());
TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>();
//Get the Number of Vertex points in the mesh with a valid node type
qint64 numNodes = triangleGeom->getNumberOfVertices();
int nNodes = 0;
// int swapped;
for (int i = 0; i < numNodes; i++)
{
if (m_SurfaceMeshNodeType[i] > 0) { ++nNodes; }
else { qDebug() << "Node Type Invalid: " << i << "::" << (int)(m_SurfaceMeshNodeType[i]) ;}
}
// This is the section header
fprintf(vtkFile, "\n");
fprintf(vtkFile, "POINT_DATA %d\n", nNodes);
fprintf(vtkFile, "SCALARS Node_Type char 1\n");
fprintf(vtkFile, "LOOKUP_TABLE default\n");
for(int i = 0; i < numNodes; ++i)
{
if(m_SurfaceMeshNodeType[i] > 0)
{
if(m_WriteBinaryFile == true)
{
// swapped = m_SurfaceMeshNodeType[i];
// SIMPLib::Endian::FromSystemToBig::convert(swapped);
fwrite(m_SurfaceMeshNodeType + i, sizeof(char), 1, vtkFile);
}
else
{
fprintf(vtkFile, "%d ", m_SurfaceMeshNodeType[i]);
}
}
}
QString attrMatName = m_SurfaceMeshNodeTypeArrayPath.getAttributeMatrixName();
#if 1
// This is from the Goldfeather Paper
writePointVectorData<double>(sm, attrMatName, "Principal_Direction_1",
"double", m_WriteBinaryFile, "VECTORS", vtkFile, numNodes);
// This is from the Goldfeather Paper
writePointVectorData<double>(sm, attrMatName, "Principal_Direction_2",
"double", m_WriteBinaryFile, "VECTORS", vtkFile, numNodes);
// This is from the Goldfeather Paper
writePointScalarData<double>(sm, attrMatName, "Principal_Curvature_1",
"double", m_WriteBinaryFile, vtkFile, numNodes);
// This is from the Goldfeather Paper
writePointScalarData<double>(sm, attrMatName, "Principal_Curvature_2",
"double", m_WriteBinaryFile, vtkFile, numNodes);
#endif
// This is from the Goldfeather Paper
writePointVectorData<double>(sm, attrMatName, SIMPL::VertexData::SurfaceMeshNodeNormals,
"double", m_WriteBinaryFile, "VECTORS", vtkFile, numNodes);
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");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int SurfaceMeshToVtk::writeCellData(FILE* vtkFile)
{
int err = 0;
if (NULL == vtkFile)
{
return -1;
}
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName());
// Write the triangle region ids
TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>();
int64_t nT = triangleGeom->getNumberOfTris();
int numTriangles = nT;
int swapped;
if (false == m_WriteConformalMesh)
{
numTriangles = nT * 2;
}
// This is like a "section header"
fprintf(vtkFile, "\n");
fprintf(vtkFile, "CELL_DATA %d\n", numTriangles);
// Write the FeatureId Data to the file
fprintf(vtkFile, "SCALARS FeatureID int 1\n");
fprintf(vtkFile, "LOOKUP_TABLE default\n");
for(int i = 0; i < nT; ++i)
{
//FaceArray::Face_t& t = triangles[i]; // Get the current Node
if(m_WriteBinaryFile == true)
{
swapped = m_SurfaceMeshFaceLabels[i * 2];
SIMPLib::Endian::FromSystemToBig::convert(swapped);
fwrite(&swapped, sizeof(int), 1, vtkFile);
if(false == m_WriteConformalMesh)
{
swapped = m_SurfaceMeshFaceLabels[i * 2 + 1];
SIMPLib::Endian::FromSystemToBig::convert(swapped);
fwrite(&swapped, sizeof(int), 1, vtkFile);
}
}
else
{
fprintf(vtkFile, "%d\n", m_SurfaceMeshFaceLabels[i * 2]);
if(false == m_WriteConformalMesh)
{
fprintf(vtkFile, "%d\n", m_SurfaceMeshFaceLabels[i * 2 + 1]);
}
}
}
#if 0
// Write the Original Triangle ID Data to the file
fprintf(vtkFile, "\n");
fprintf(vtkFile, "SCALARS TriangleID int 1\n");
fprintf(vtkFile, "LOOKUP_TABLE default\n");
for(int i = 0; i < nT; ++i)
{
//Triangle& t = triangles[i]; // Get the current Node
if(m_WriteBinaryFile == true)
{
swapped = i;
SIMPLib::Endian::FromSystemToBig::convert(swapped);
fwrite(&swapped, sizeof(int), 1, vtkFile);
if(false == m_WriteConformalMesh)
{
fwrite(&swapped, sizeof(int), 1, vtkFile);
}
}
else
{
fprintf(vtkFile, "%d\n", i);
if(false == m_WriteConformalMesh)
{
fprintf(vtkFile, "%d\n", i);
}
}
}
#endif
QString attrMatName = m_SurfaceMeshFaceLabelsArrayPath.getAttributeMatrixName();
writeCellScalarData<int32_t>(sm, attrMatName, DREAM3D::FaceData::SurfaceMeshFeatureFaceId,
"int", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, nT);
writeCellScalarData<double>(sm, attrMatName, DREAM3D::FaceData::SurfaceMeshPrincipalCurvature1,
"double", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, nT);
writeCellScalarData<double>(sm, attrMatName, DREAM3D::FaceData::SurfaceMeshPrincipalCurvature2,
"double", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, nT);
writeCellVectorData<double>(sm, attrMatName, DREAM3D::FaceData::SurfaceMeshPrincipalDirection1,
"double", m_WriteBinaryFile, m_WriteConformalMesh, "VECTORS", vtkFile, nT);
writeCellVectorData<double>(sm, attrMatName, DREAM3D::FaceData::SurfaceMeshPrincipalDirection2,
"double", m_WriteBinaryFile, m_WriteConformalMesh, "VECTORS", vtkFile, nT);
writeCellScalarData<double>(sm, attrMatName, DREAM3D::FaceData::SurfaceMeshGaussianCurvatures,
"double", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, nT);
writeCellScalarData<double>(sm, attrMatName, DREAM3D::FaceData::SurfaceMeshMeanCurvatures,
"double", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, nT);
writeCellNormalData<double>(sm, attrMatName, DREAM3D::FaceData::SurfaceMeshFaceNormals,
"double", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, nT);
writeCellNormalData<double>(sm, attrMatName, "Goldfeather_Triangle_Normals",
"double", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, nT);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int SurfaceMeshToNonconformalVtk::writeCellData(FILE* vtkFile, QMap<int32_t, int32_t>& featureIds)
{
int err = 0;
if (NULL == vtkFile)
{
return -1;
}
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName());
// Write the triangle region ids
TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>();
int64_t numTriangles = triangleGeom->getNumberOfTris();
int swapped;
// This is like a "section header"
fprintf(vtkFile, "\n");
fprintf(vtkFile, "CELL_DATA %lld\n", (long long int)(numTriangles * 2));
int32_t totalCellsWritten = 0;
// Write the FeatureId Data to the file
fprintf(vtkFile, "SCALARS FeatureID int 1\n");
fprintf(vtkFile, "LOOKUP_TABLE default\n");
// Loop over all the features
for(QMap<int32_t, int32_t>::iterator featureIter = featureIds.begin(); featureIter != featureIds.end(); ++featureIter)
{
int32_t gid = featureIter.key(); // The current Feature Id
size_t size = featureIter.value(); // The number of triangles for this feature id
std::vector<int32_t> buffer(size, 0);
totalCellsWritten += size;
// Endian Swap our current feature Id since we are going to write it a bunch of times.
swapped = gid;
SIMPLib::Endian::FromSystemToBig::convert(swapped);
size_t index = 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++)
{
if (m_SurfaceMeshFaceLabels[j * 2] == gid || m_SurfaceMeshFaceLabels[j * 2 + 1] == gid)
{
if(m_WriteBinaryFile == true)
{
buffer[index] = swapped;
++index;
}
else
{
fprintf(vtkFile, "%d\n", gid);
}
}
}
// Write the Buffer
if(m_WriteBinaryFile == true)
{
fwrite(&(buffer.front()), sizeof(int32_t), size, vtkFile);
}
}
#if 0
// Write the Original Triangle ID Data to the file
fprintf(vtkFile, "\n");
fprintf(vtkFile, "SCALARS TriangleID int 1\n");
fprintf(vtkFile, "LOOKUP_TABLE default\n");
for(int i = 0; i < triangleCount * 2; ++i)
{
//Triangle& t = triangles[i]; // Get the current Node
if(m_WriteBinaryFile == true)
{
swapped = i;
SIMPLib::Endian::FromSystemToBig::convert(swapped);
fwrite(&swapped, sizeof(int), 1, vtkFile);
fwrite(&swapped, sizeof(int), 1, vtkFile);
}
else
{
fprintf(vtkFile, "%d\n", i);
fprintf(vtkFile, "%d\n", i);
}
}
#endif
QString attrMatName = m_SurfaceMeshFaceLabelsArrayPath.getAttributeMatrixName();
notifyStatusMessage(getHumanLabel(), "Writing Face Normals...");
writeCellNormalData<double>(sm, attrMatName, SIMPL::FaceData::SurfaceMeshFaceNormals,
"double", m_WriteBinaryFile, vtkFile, featureIds, m_SurfaceMeshFaceLabels);
notifyStatusMessage(getHumanLabel(), "Writing Principal Curvature 1");
writeCellScalarData<double>(sm, attrMatName, SIMPL::FaceData::SurfaceMeshPrincipalCurvature1,
"double", m_WriteBinaryFile, vtkFile, featureIds, m_SurfaceMeshFaceLabels);
notifyStatusMessage(getHumanLabel(), "Writing Principal Curvature 2");
writeCellScalarData<double>(sm, attrMatName, SIMPL::FaceData::SurfaceMeshPrincipalCurvature2,
"double", m_WriteBinaryFile, vtkFile, featureIds, m_SurfaceMeshFaceLabels);
notifyStatusMessage(getHumanLabel(), "Writing Feature Face Id");
writeCellScalarData<int32_t>(sm, attrMatName, SIMPL::FaceData::SurfaceMeshFeatureFaceId,
"int", m_WriteBinaryFile, vtkFile, featureIds, m_SurfaceMeshFaceLabels);
notifyStatusMessage(getHumanLabel(), "Writing Gaussian Curvature");
writeCellScalarData<double>(sm, attrMatName, SIMPL::FaceData::SurfaceMeshGaussianCurvatures,
"double", m_WriteBinaryFile, vtkFile, featureIds, m_SurfaceMeshFaceLabels);
notifyStatusMessage(getHumanLabel(), "Writing Mean Curvature");
writeCellScalarData<double>(sm, attrMatName, SIMPL::FaceData::SurfaceMeshMeanCurvatures,
"double", m_WriteBinaryFile, vtkFile, featureIds, m_SurfaceMeshFaceLabels);
#if 0
writeCellVectorData<double>(sm, attrMatName, SIMPL::CellData::SurfaceMeshPrincipalDirection1,
"double", m_WriteBinaryFile, "VECTORS", vtkFile, nT);
writeCellVectorData<double>(sm, attrMatName, SIMPL::CellData::SurfaceMeshPrincipalDirection2,
"double", m_WriteBinaryFile, "VECTORS", vtkFile, nT);
writeCellNormalData<double>(sm, attrMatName, "Goldfeather_Triangle_Normals",
"double", m_WriteBinaryFile, vtkFile, nT);
#endif
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SharedFeatureFaceFilter::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName());
AttributeMatrix::Pointer faceFeatureAttrMat = sm->getAttributeMatrix(getFaceFeatureAttributeMatrixName());
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
int64_t totalPoints = triangleGeom->getNumberOfTris();
QMap<uint64_t, int32_t> faceSizeMap;
QMap<uint64_t, int32_t> faceIdMap; // This maps a unique 64 bit integer to an increasing 32 bit integer
int32_t index = 1;
struct { int g; int r; } faceId;
uint64_t* faceId_64 = reinterpret_cast<uint64_t*>(&faceId);
int32_t fl0 = -1;
int32_t fl1 = -1;
std::vector< std::pair<int32_t, int32_t> > faceLabelMap;
faceLabelMap.push_back( std::pair<int32_t, int32_t>(0, 0) );
// Loop through all the Triangles and figure out how many triangles we have in each one.
for (int64_t t = 0; t < totalPoints; ++t)
{
fl0 = m_SurfaceMeshFaceLabels[t * 2];
fl1 = m_SurfaceMeshFaceLabels[t * 2 + 1];
if (fl0 < fl1)
{
faceId.g = fl0;
faceId.r = fl1;
}
else
{
faceId.g = fl1;
faceId.r = fl0;
}
QMap<uint64_t, int32_t>::iterator iter = faceSizeMap.find(*faceId_64);
if (iter == faceSizeMap.end())
{
faceSizeMap[*faceId_64] = 1;
faceIdMap[*faceId_64] = index;
m_SurfaceMeshFeatureFaceIds[t] = index;
faceLabelMap.push_back( std::pair<int32_t, int32_t>(faceId.g, faceId.r) );
++index;
}
else
{
iter.value()++;
m_SurfaceMeshFeatureFaceIds[t] = faceIdMap[*faceId_64];
}
}
// resize + update pointers
QVector<size_t> tDims(1, index);
faceFeatureAttrMat->resizeAttributeArrays(tDims);
m_SurfaceMeshFeatureFaceLabels = m_SurfaceMeshFeatureFaceLabelsPtr.lock()->getPointer(0);
m_SurfaceMeshFeatureFaceNumTriangles = m_SurfaceMeshFeatureFaceNumTrianglesPtr.lock()->getPointer(0);
for (int32_t i = 0; i < index; i++)
{
// get feature face labels
m_SurfaceMeshFeatureFaceLabels[2 * i + 0] = faceLabelMap[i].first;
m_SurfaceMeshFeatureFaceLabels[2 * i + 1] = faceLabelMap[i].second;
// get feature triangle count
faceId.g = faceLabelMap[i].first;
faceId.r = faceLabelMap[i].second;
m_SurfaceMeshFeatureFaceNumTriangles[i] = faceSizeMap[*faceId_64];
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int DataContainer::readMeshDataFromHDF5(hid_t dcGid, bool preflight)
{
herr_t err = 0;
unsigned int geometryType = DREAM3D::GeometryType::UnknownGeometry;
err = QH5Lite::readScalarAttribute(dcGid, DREAM3D::Geometry::Geometry, DREAM3D::Geometry::GeometryType, geometryType);
if (err < 0)
{
return err;
}
hid_t geometryId = H5Gopen(dcGid, DREAM3D::Geometry::Geometry.toLatin1().data(), H5P_DEFAULT);
if (geometryId < 0)
{
return -1;
}
HDF5ScopedGroupSentinel gSentinel(&geometryId, false);
IGeometry::Pointer geomPtr = IGeometry::NullPointer();
if (NULL == m_Geometry.get())
{
switch(geometryType)
{
case DREAM3D::GeometryType::ImageGeometry:
{
ImageGeom::Pointer image = ImageGeom::New();
err = image->readGeometryFromHDF5(geometryId, preflight);
err = GeometryHelpers::GeomIO::ReadMetaDataFromHDF5(dcGid, image);
setGeometry(image);
break;
}
case DREAM3D::GeometryType::VertexGeometry:
{
VertexGeom::Pointer vertices = VertexGeom::New();
err = vertices->readGeometryFromHDF5(geometryId, preflight);
err = GeometryHelpers::GeomIO::ReadMetaDataFromHDF5(dcGid, vertices);
setGeometry(vertices);
break;
}
case DREAM3D::GeometryType::EdgeGeometry:
{
EdgeGeom::Pointer edges = EdgeGeom::New();
err = edges->readGeometryFromHDF5(geometryId, preflight);
err = GeometryHelpers::GeomIO::ReadMetaDataFromHDF5(dcGid, edges);
setGeometry(edges);
break;
}
case DREAM3D::GeometryType::TriangleGeometry:
{
TriangleGeom::Pointer triangles = TriangleGeom::New();
err = triangles->readGeometryFromHDF5(geometryId, preflight);
err = GeometryHelpers::GeomIO::ReadMetaDataFromHDF5(dcGid, triangles);
setGeometry(triangles);
break;
}
case DREAM3D::GeometryType::QuadGeometry:
{
QuadGeom::Pointer quads = QuadGeom::New();
err = quads->readGeometryFromHDF5(geometryId, preflight);
err = GeometryHelpers::GeomIO::ReadMetaDataFromHDF5(dcGid, quads);
setGeometry(quads);
break;
}
case DREAM3D::GeometryType::UnknownGeometry:
setGeometry(geomPtr);
break;
default:
setGeometry(geomPtr);
break;
}
}
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int32_t AbaqusSurfaceMeshWriter::writeFeatures(FILE* f)
{
//*Elset, elset=Feature1
//1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
int32_t err = 0;
TriangleGeom::Pointer triangleGeo = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>();
int64_t nTriangles = triangleGeo->getNumberOfTris();
// Store all the unique Spins
std::set<int32_t> uniqueSpins;
for (int64_t i = 0; i < nTriangles; i++)
{
uniqueSpins.insert(m_SurfaceMeshFaceLabels[i * 2]);
uniqueSpins.insert(m_SurfaceMeshFaceLabels[i * 2 + 1]);
}
int32_t spin = 0;
//Loop over the unique Spins
for (std::set<int32_t>::iterator spinIter = uniqueSpins.begin(); spinIter != uniqueSpins.end(); ++spinIter )
{
spin = *spinIter;
if (spin < 0) { continue; }
fprintf(f, "*ELSET, ELSET=Feature%d\n", spin);
{
QString ss = QObject::tr("Writing ELSET for Feature Id %1").arg(spin);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
}
// Loop over all the triangles for this spin
int64_t lineCount = 0;
for (int64_t t = 0; t < nTriangles; ++t)
{
if (m_SurfaceMeshFaceLabels[t * 2] != spin && m_SurfaceMeshFaceLabels[t * 2 + 1] != spin)
{
continue; // We do not match either spin so move to the next triangle
}
// Only print 15 Triangles per line
if (lineCount == 15)
{
fprintf (f, ", %lld\n", (long long int)(t));
lineCount = 0;
}
else if(lineCount == 0) // First value on the line
{
fprintf(f, "%lld", (long long int)(t));
lineCount++;
}
else
{
fprintf(f, ", %lld", (long long int)(t));
lineCount++;
}
}
// Make sure we have a new line at the end of the section
if (lineCount != 0)
{
fprintf(f, "\n");
}
}
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 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");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int SurfaceMeshToVtk::writePointData(FILE* vtkFile)
{
int err = 0;
if (NULL == vtkFile)
{
return -1;
}
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(m_SurfaceMeshFaceLabelsArrayPath.getDataContainerName());
TriangleGeom::Pointer triangleGeom = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName())->getGeometryAs<TriangleGeom>();
qint64 numNodes = triangleGeom->getNumberOfVertices();
int64_t numberWrittenumNodes = 0;
// Write the Node Type Data to the file
for (int i = 0; i < numNodes; i++)
{
if (m_SurfaceMeshNodeType[i] > 0) { ++numberWrittenumNodes; }
}
// This is the section header
fprintf(vtkFile, "\n");
fprintf(vtkFile, "POINT_DATA %lld\n", (long long int)(numberWrittenumNodes));
fprintf(vtkFile, "SCALARS Node_Type char 1\n");
fprintf(vtkFile, "LOOKUP_TABLE default\n");
for(int i = 0; i < numNodes; ++i)
{
if(m_SurfaceMeshNodeType[i] > 0)
{
if(m_WriteBinaryFile == true)
{
// Normally, we would byte swap to big endian but since we are only writing
// 1 byte Char values, nothing to swap.
fwrite(m_SurfaceMeshNodeType + i, sizeof(char), 1, vtkFile);
}
else
{
fprintf(vtkFile, "%d ", m_SurfaceMeshNodeType[i]);
}
}
}
QString attrMatName = m_SurfaceMeshNodeTypeArrayPath.getAttributeMatrixName();
#if 1
// This is from the Goldfeather Paper
writePointVectorData<double>(sm, attrMatName, "Principal_Direction_1",
"double", m_WriteBinaryFile, m_WriteConformalMesh, "VECTORS", vtkFile, numNodes);
// This is from the Goldfeather Paper
writePointVectorData<double>(sm, attrMatName, "Principal_Direction_2",
"double", m_WriteBinaryFile, m_WriteConformalMesh, "VECTORS", vtkFile, numNodes);
// This is from the Goldfeather Paper
writePointScalarData<double>(sm, attrMatName, "Principal_Curvature_1",
"double", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, numNodes);
// This is from the Goldfeather Paper
writePointScalarData<double>(sm, attrMatName, "Principal_Curvature_2",
"double", m_WriteBinaryFile, m_WriteConformalMesh, vtkFile, numNodes);
#endif
// This is from the Goldfeather Paper
writePointVectorData<double>(sm, attrMatName, DREAM3D::VertexData::SurfaceMeshNodeNormals,
"double", m_WriteBinaryFile, m_WriteConformalMesh, "VECTORS", vtkFile, numNodes);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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];
}
}
