// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 ScaleVolume::updateSurfaceMesh()
{
setErrorCondition(0);
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
IGeometry2D::Pointer geom2D = getDataContainerArray()->getDataContainer(getSurfaceDataContainerName())->getGeometryAs<IGeometry2D>();
float* nodes = geom2D->getVertexPointer(0);
// First get the min/max coords.
float min[3] = { std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max() };
float max[3] = { std::numeric_limits<float>::min(), std::numeric_limits<float>::min(), std::numeric_limits<float>::min() };
int64_t count = geom2D->getNumberOfVertices();
for (int64_t i = 0; i < count; i++)
{
if (nodes[3 * i] > max[0])
{
max[0] = nodes[3 * i];
}
if (nodes[3 * i + 1] > max[1])
{
max[1] = nodes[3 * i + 1];
}
if (nodes[3 * i + 2] > max[2])
{
max[2] = nodes[3 * i + 2];
}
if (nodes[3 * i] < min[0])
{
min[0] = nodes[3 * i];
}
if (nodes[3 * i + 1] < min[1])
{
min[1] = nodes[3 * i + 1];
}
if (nodes[3 * i + 2] < min[2])
{
min[2] = nodes[3 * i + 2];
}
}
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, count),
UpdateVerticesImpl(nodes, min, m_ScaleFactor), tbb::auto_partitioner());
}
else
#endif
{
UpdateVerticesImpl serial(nodes, min, m_ScaleFactor);
serial.generate(0, count);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateGeometryConnectivity::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setSurfaceDataContainerName(reader->readString("SurfaceDataContainerName", getSurfaceDataContainerName() ) );
setGenerateVertexTriangleLists( reader->readValue("GenerateVertexTriangleLists", getGenerateVertexTriangleLists()) );
setGenerateTriangleNeighbors( reader->readValue("GenerateTriangleNeighbors", getGenerateTriangleNeighbors()) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ScaleVolume::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setApplyToVoxelVolume( reader->readValue("ApplyToVoxelVolume", getApplyToVoxelVolume()) );
setApplyToSurfaceMesh( reader->readValue("ApplyToSurfaceMesh", getApplyToSurfaceMesh()) );
setScaleFactor( reader->readFloatVec3("ScaleFactor", getScaleFactor() ) );
setDataContainerName(reader->readString("DataContainerName", getDataContainerName()));
setSurfaceDataContainerName(reader->readString("SurfaceDataContainerName", getSurfaceDataContainerName()));
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateGeometryConnectivity::execute()
{
int32_t err = 0;
setErrorCondition(err);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceDataContainerName());
IGeometry::Pointer geom = sm->getGeometry();
if (m_GenerateVertexTriangleLists == true || m_GenerateTriangleNeighbors == true)
{
notifyStatusMessage(getHumanLabel(), "Generating Vertex Element List");
err = geom->findElementsContainingVert();
if (err < 0)
{
setErrorCondition(-400);
QString ss = QObject::tr("Error generating vertex element list for Geometry type %1").arg(geom->getGeometryTypeAsString());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
if (m_GenerateTriangleNeighbors == true)
{
notifyStatusMessage(getHumanLabel(), "Generating Element Neighbors List");
err = geom->findElementNeighbors();
if (err < 0)
{
setErrorCondition(-401);
QString ss = QObject::tr("Error generating element neighbor list for Geometry type %1").arg(geom->getGeometryTypeAsString());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ScaleVolume::dataCheck()
{
setErrorCondition(0);
if (m_ApplyToVoxelVolume == true)
{
getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getDataContainerName());
}
if (m_ApplyToSurfaceMesh == true)
{
getDataContainerArray()->getPrereqGeometryFromDataContainer<IGeometry2D, AbstractFilter>(this, getSurfaceDataContainerName());
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ScaleVolume::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(FloatVec3FilterParameter::New("Scaling Factor", "ScaleFactor", getScaleFactor(), FilterParameter::Parameter));
QStringList linkedProps("DataContainerName");
parameters.push_back(LinkedBooleanFilterParameter::New("Apply to Image Geometry", "ApplyToVoxelVolume", getApplyToVoxelVolume(), linkedProps, FilterParameter::Parameter));
parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container Image Geometry to Scale", "DataContainerName", getDataContainerName(), FilterParameter::RequiredArray));
linkedProps.clear();
linkedProps << "SurfaceDataContainerName";
parameters.push_back(LinkedBooleanFilterParameter::New("Apply to Surface Geometry", "ApplyToSurfaceMesh", getApplyToSurfaceMesh(), linkedProps, FilterParameter::Parameter));
parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container Surface Geometry to Scale", "SurfaceDataContainerName", getSurfaceDataContainerName(), FilterParameter::RequiredArray));
setFilterParameters(parameters);
}
void LaplacianSmoothing::writeVTKFile(const QString& outputVtkFile)
{
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceDataContainerName()); /* Place all your code to execute your filter here. */
VertexArray& nodes = *(sm->getVertices());
int nNodes = nodes.getNumberOfTuples();
bool m_WriteBinaryFile = true;
FILE* vtkFile = NULL;
vtkFile = fopen(outputVtkFile.toLatin1().data(), "wb");
if (NULL == vtkFile)
{
setErrorCondition(-90123);
QString ss = QObject::tr("Error creating file '%1'").arg(outputVtkFile);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
Detail::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");
fprintf(vtkFile, "POINTS %d float\n", nNodes);
float pos[3] = {0.0f, 0.0f, 0.0f};
size_t totalWritten = 0;
// Write the POINTS data (Vertex)
for (int i = 0; i < nNodes; i++)
{
VertexArray::Vert_t& n = nodes[i]; // Get the current Node
// if (m_SurfaceMeshNodeType[i] > 0)
{
pos[0] = static_cast<float>(n.pos[0]);
pos[1] = static_cast<float>(n.pos[1]);
pos[2] = static_cast<float>(n.pos[2]);
if (m_WriteBinaryFile == true)
{
DREAM3D::Endian::FromSystemToBig::convert<float>(pos[0]);
DREAM3D::Endian::FromSystemToBig::convert<float>(pos[1]);
DREAM3D::Endian::FromSystemToBig::convert<float>(pos[2]);
totalWritten = fwrite(pos, sizeof(float), 3, vtkFile);
if (totalWritten != sizeof(float) * 3)
{
}
}
else
{
fprintf(vtkFile, "%4.4f %4.4f %4.4f\n", pos[0], pos[1], pos[2]); // Write the positions to the output file
}
}
}
// Write the triangle indices into the vtk File
FaceArray& triangles = *(sm->getFaces());
int triangleCount = 0;
int end = triangles.getNumberOfTuples();
int featureInterest = 9;
for(int i = 0; i < end; ++i)
{
//FaceArray::Face_t* tri = triangles.getPointer(i);
if (m_SurfaceMeshFaceLabels[i * 2] == featureInterest || m_SurfaceMeshFaceLabels[i * 2 + 1] == featureInterest)
{
++triangleCount;
}
}
int tData[4];
// Write the CELLS Data
// int start = 3094380;
// int end = 3094450;
// int triangleCount = end - start;
qDebug() << "---------------------------------------------------------------------------" << "\n";
qDebug() << outputVtkFile << "\n";
fprintf(vtkFile, "\nPOLYGONS %d %d\n", triangleCount, (triangleCount * 4));
for (int tid = 0; tid < end; ++tid)
{
//FaceArray::Face_t* tri = triangles.getPointer(tid);
if (m_SurfaceMeshFaceLabels[tid * 2] == featureInterest || m_SurfaceMeshFaceLabels[tid * 2 + 1] == featureInterest)
{
tData[1] = triangles[tid].verts[0];
tData[2] = triangles[tid].verts[1];
tData[3] = triangles[tid].verts[2];
// qDebug() << tid << "\n " << nodes[tData[1]].coord[0] << " " << nodes[tData[1]].coord[1] << " " << nodes[tData[1]].coord[2] << "\n";
// qDebug() << " " << nodes[tData[2]].coord[0] << " " << nodes[tData[2]].coord[1] << " " << nodes[tData[2]].coord[2] << "\n";
// qDebug() << " " << nodes[tData[3]].coord[0] << " " << nodes[tData[3]].coord[1] << " " << nodes[tData[3]].coord[2] << "\n";
if (m_WriteBinaryFile == true)
{
tData[0] = 3; // Push on the total number of entries for this entry
DREAM3D::Endian::FromSystemToBig::convert<int>(tData[0]);
DREAM3D::Endian::FromSystemToBig::convert<int>(tData[1]); // Index of Vertex 0
DREAM3D::Endian::FromSystemToBig::convert<int>(tData[2]); // Index of Vertex 1
DREAM3D::Endian::FromSystemToBig::convert<int>(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]);
}
}
}
fprintf(vtkFile, "\n");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int32_t LaplacianSmoothing::edgeBasedSmoothing()
{
int32_t err = 0;
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceDataContainerName());
IGeometry2D::Pointer surfaceMesh = sm->getGeometryAs<IGeometry2D>();
float* verts = surfaceMesh->getVertexPointer(0);
int64_t nvert = surfaceMesh->getNumberOfVertices();
// Generate the Lambda Array
err = generateLambdaArray();
if (err < 0)
{
setErrorCondition(-557);
notifyErrorMessage(getHumanLabel(), "Error generating the lambda array", getErrorCondition());
return err;
}
// Get a Pointer to the Lambda array for conveneince
DataArray<float>::Pointer lambdas = getLambdaArray();
float* lambda = lambdas->getPointer(0);
// Generate the Unique Edges
if (NULL == surfaceMesh->getEdges().get())
{
err = surfaceMesh->findEdges();
}
if (err < 0)
{
setErrorCondition(-560);
notifyErrorMessage(getHumanLabel(), "Error retrieving the shared edge list", getErrorCondition());
return getErrorCondition();
}
int64_t* uedges = surfaceMesh->getEdgePointer(0);
int64_t nedges = surfaceMesh->getNumberOfEdges();
DataArray<int32_t>::Pointer numConnections = DataArray<int32_t>::CreateArray(nvert, "_INTERNAL_USE_ONLY_Laplacian_Smoothing_NumberConnections_Array");
numConnections->initializeWithZeros();
int32_t* ncon = numConnections->getPointer(0);
QVector<size_t> cDims(1, 3);
DataArray<double>::Pointer deltaArray = DataArray<double>::CreateArray(nvert, cDims, "_INTERNAL_USE_ONLY_Laplacian_Smoothing_Delta_Array");
deltaArray->initializeWithZeros();
double* delta = deltaArray->getPointer(0);
double dlta = 0.0;
for (int32_t q = 0; q < m_IterationSteps; q++)
{
if (getCancel() == true) { return -1; }
QString ss = QObject::tr("Iteration %1").arg(q);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
for (int64_t i = 0; i < nedges; i++)
{
int64_t in1 = uedges[2 * i]; // row of the first vertex
int64_t in2 = uedges[2 * i + 1]; // row the second vertex
for (int32_t j = 0; j < 3; j++)
{
BOOST_ASSERT( static_cast<size_t>(3 * in1 + j) < static_cast<size_t>(nvert * 3) );
BOOST_ASSERT( static_cast<size_t>(3 * in2 + j) < static_cast<size_t>(nvert * 3) );
dlta = verts[3 * in2 + j] - verts[3 * in1 + j];
delta[3 * in1 + j] += dlta;
delta[3 * in2 + j] += -1.0 * dlta;
}
ncon[in1] += 1;
ncon[in2] += 1;
}
float ll = 0.0f;
for (int64_t i = 0; i < nvert; i++)
{
for (int32_t j = 0; j < 3; j++)
{
int64_t in0 = 3 * i + j;
dlta = delta[in0] / ncon[i];
ll = lambda[i];
verts[3 * i + j] += ll * dlta;
delta[in0] = 0.0; // reset for next iteration
}
ncon[i] = 0; // reset for next iteration
}
}
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateGeometryConnectivity::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(BooleanFilterParameter::New("Generate Per Vertex Element List", "GenerateVertexTriangleLists", getGenerateVertexTriangleLists(), FilterParameter::Parameter));
parameters.push_back(BooleanFilterParameter::New("Generate Element Neighbors List", "GenerateTriangleNeighbors", getGenerateTriangleNeighbors(), FilterParameter::Parameter));
{
DataContainerSelectionFilterParameter::RequirementType req;
parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container", "SurfaceDataContainerName", getSurfaceDataContainerName(), FilterParameter::RequiredArray, req));
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateGeometryConnectivity::dataCheck()
{
getDataContainerArray()->getPrereqGeometryFromDataContainer<IGeometry, AbstractFilter>(this, getSurfaceDataContainerName());
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ScaleVolume::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(FloatVec3FilterParameter::New("Scaling Factor", "ScaleFactor", getScaleFactor(), FilterParameter::Parameter));
QStringList linkedProps("DataContainerName");
parameters.push_back(LinkedBooleanFilterParameter::New("Apply to Image Geometry", "ApplyToVoxelVolume", getApplyToVoxelVolume(), linkedProps, FilterParameter::Parameter));
{
DataContainerSelectionFilterParameter::RequirementType req;
req.dcGeometryTypes = QVector<unsigned int>(1, DREAM3D::GeometryType::ImageGeometry);
parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container Image Geometry to Scale", "DataContainerName", getDataContainerName(), FilterParameter::RequiredArray, req));
}
linkedProps.clear();
linkedProps << "SurfaceDataContainerName";
parameters.push_back(LinkedBooleanFilterParameter::New("Apply to Surface Geometry", "ApplyToSurfaceMesh", getApplyToSurfaceMesh(), linkedProps, FilterParameter::Parameter));
{
DataContainerSelectionFilterParameter::RequirementType req;
QVector<unsigned int> dcGeometryTypes;
dcGeometryTypes.push_back(DREAM3D::GeometryType::TriangleGeometry);
dcGeometryTypes.push_back(DREAM3D::GeometryType::QuadGeometry);
req.dcGeometryTypes = dcGeometryTypes;
parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container Surface Geometry to Scale", "SurfaceDataContainerName", getSurfaceDataContainerName(), FilterParameter::RequiredArray, req));
}
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReverseTriangleWinding::dataCheck()
{
getDataContainerArray()->getPrereqGeometryFromDataContainer<TriangleGeom, AbstractFilter>(this, getSurfaceDataContainerName());
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReverseTriangleWinding::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setSurfaceDataContainerName(reader->readString("SurfaceDataContainerName", getSurfaceDataContainerName() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ReverseTriangleWinding::setupFilterParameters()
{
FilterParameterVector parameters;
{
DataContainerSelectionFilterParameter::RequirementType req;
req.dcGeometryTypes = QVector<unsigned int>(1, SIMPL::GeometryType::TriangleGeometry);
parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container", "SurfaceDataContainerName", getSurfaceDataContainerName(), FilterParameter::RequiredArray, req));
}
setFilterParameters(parameters);
}
