// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindModulusMismatch::execute() { setErrorCondition(0); dataCheckVoxel(); if(getErrorCondition() < 0) { return; } dataCheckSurfaceMesh(); if(getErrorCondition() < 0) { return; } #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS tbb::task_scheduler_init init; bool doParallel = true; #endif int64_t numTriangles = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples(); #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS if (doParallel == true) { tbb::parallel_for(tbb::blocked_range<size_t>(0, numTriangles), FindModulusMismatchImpl(m_SurfaceMeshFaceLabels, m_Moduli, m_SurfaceMeshDeltaModulus), tbb::auto_partitioner()); } else #endif { FindModulusMismatchImpl serial(m_SurfaceMeshFaceLabels, m_Moduli, m_SurfaceMeshDeltaModulus); serial.generate(0, numTriangles); } notifyStatusMessage(getHumanLabel(), "Completed"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GenerateFaceSchuhMisorientationColoring::execute() { int err = 0; setErrorCondition(err); dataCheckSurfaceMesh(); if(getErrorCondition() < 0) { return; } dataCheckVoxel(); if(getErrorCondition() < 0) { return; } notifyStatusMessage(getMessagePrefix(), getHumanLabel(), "Starting"); // Run the data check to allocate the memory for the centroid array int64_t numTriangles = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples(); #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS bool doParallel = true; #endif #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS if (doParallel == true) { tbb::parallel_for(tbb::blocked_range<size_t>(0, numTriangles), CalculateFaceSchuhMisorientationColorsImpl(m_SurfaceMeshFaceLabels, m_FeaturePhases, m_AvgQuats, m_SurfaceMeshFaceSchuhMisorientationColors, m_CrystalStructures), tbb::auto_partitioner()); } else #endif { CalculateFaceSchuhMisorientationColorsImpl serial(m_SurfaceMeshFaceLabels, m_FeaturePhases, m_AvgQuats, m_SurfaceMeshFaceSchuhMisorientationColors, m_CrystalStructures); serial.generate(0, numTriangles); } /* Let the GUI know we are done with this filter */ notifyStatusMessage(getHumanLabel(), "Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindModulusMismatch::preflight() { setInPreflight(true); emit preflightAboutToExecute(); emit updateFilterParameters(this); dataCheckVoxel(); dataCheckSurfaceMesh(); emit preflightExecuted(); setInPreflight(false); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GenerateFaceSchuhMisorientationColoring::preflight() { setInPreflight(true); emit preflightAboutToExecute(); emit updateFilterParameters(this); dataCheckSurfaceMesh(); dataCheckVoxel(); emit preflightExecuted(); setInPreflight(false); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindTwinBoundarySchmidFactors::preflight() { setInPreflight(true); emit preflightAboutToExecute(); emit updateFilterParameters(this); dataCheckVoxel(); dataCheckSurfaceMesh(); emit preflightExecuted(); setInPreflight(false); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindGBCD::preflight() { setInPreflight(true); emit preflightAboutToExecute(); emit updateFilterParameters(this); dataCheckVoxel(); // order here matters...because we are going to use the size of the crystal structures out of the dataCheckVoxel to size the faceAttrMat in dataCheckSurfaceMesh if (getErrorCondition() >= 0) { dataCheckSurfaceMesh(); } emit preflightExecuted(); setInPreflight(false); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindTwinBoundarySchmidFactors::execute() { setErrorCondition(0); dataCheckVoxel(); if(getErrorCondition() < 0) { return; } dataCheckSurfaceMesh(); if(getErrorCondition() < 0) { return; } #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS tbb::task_scheduler_init init; bool doParallel = true; #endif size_t numTriangles = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples(); float LoadingDir[3] = { 0.0f, 0.0f, 0.0f }; LoadingDir[0] = m_LoadingDir.x; LoadingDir[1] = m_LoadingDir.y; LoadingDir[2] = m_LoadingDir.z; #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS if (doParallel == true) { tbb::parallel_for(tbb::blocked_range<size_t>(0, numTriangles), CalculateTwinBoundarySchmidFactorsImpl(LoadingDir, m_SurfaceMeshFaceLabels, m_SurfaceMeshFaceNormals, m_AvgQuats, m_SurfaceMeshTwinBoundary, m_SurfaceMeshTwinBoundarySchmidFactors), tbb::auto_partitioner()); } else #endif { CalculateTwinBoundarySchmidFactorsImpl serial(LoadingDir, m_SurfaceMeshFaceLabels, m_SurfaceMeshFaceNormals, m_AvgQuats, m_SurfaceMeshTwinBoundary, m_SurfaceMeshTwinBoundarySchmidFactors); serial.generate(0, numTriangles); } if (m_WriteFile == true) { std::ofstream outFile; outFile.open(m_TwinBoundarySchmidFactorsFile.toLatin1().data(), std::ios_base::binary); outFile << "Feature1 Feature2 IsTwin Plane Schmid1 Schmid2 Schmid3" << "\n"; for (size_t i = 0; i < numTriangles; i++) { outFile << m_SurfaceMeshFaceLabels[2 * i] << " " << m_SurfaceMeshFaceLabels[2 * i + 1] << " " << m_SurfaceMeshTwinBoundary[i] << " " << m_SurfaceMeshTwinBoundarySchmidFactors[3 * i] << " " << m_SurfaceMeshTwinBoundarySchmidFactors[3 * i + 1] << " " << m_SurfaceMeshTwinBoundarySchmidFactors[3 * i + 2] << "\n"; } outFile.close(); } notifyStatusMessage(getHumanLabel(), "Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindGBCD::execute() { setErrorCondition(0); dataCheckVoxel(); if(getErrorCondition() < 0) { return; } // order here matters...because we are going to use the size of the crystal structures out of the dataCheckVoxel to size the faceAttrMat in dataCheckSurfaceMesh dataCheckSurfaceMesh(); if(getErrorCondition() < 0) { return; } #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS tbb::task_scheduler_init init; bool doParallel = true; #endif size_t totalPhases = m_CrystalStructuresPtr.lock()->getNumberOfTuples(); size_t totalFaces = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples(); size_t faceChunkSize = 50000; size_t numMisoReps = 576 * 4; if (totalFaces < faceChunkSize) { faceChunkSize = totalFaces; } // call the sizeGBCD function with proper chunkSize and numMisoReps to get Bins array set up properly sizeGBCD(faceChunkSize, numMisoReps); int32_t totalGBCDBins = m_GbcdSizes[0] * m_GbcdSizes[1] * m_GbcdSizes[2] * m_GbcdSizes[3] * m_GbcdSizes[4] * 2; uint64_t millis = QDateTime::currentMSecsSinceEpoch(); uint64_t currentMillis = millis; uint64_t startMillis = millis; uint64_t estimatedTime = 0; float timeDiff = 0.0f; startMillis = QDateTime::currentMSecsSinceEpoch(); int32_t hemisphere = 0; //create an array to hold the total face area for each phase and initialize the array to 0.0 DoubleArrayType::Pointer totalFaceAreaPtr = DoubleArrayType::CreateArray(totalPhases, "totalFaceArea"); totalFaceAreaPtr->initializeWithValue(0.0); double* totalFaceArea = totalFaceAreaPtr->getPointer(0); QString ss = QObject::tr("Calculating GBCD || 0/%1 Completed").arg(totalFaces); for (size_t i = 0; i < totalFaces; i = i + faceChunkSize) { if(getCancel() == true) { return; } if (i + faceChunkSize >= totalFaces) { faceChunkSize = totalFaces - i; } m_GbcdBinsArray->initializeWithValue(-1); #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS if (doParallel == true) { tbb::parallel_for(tbb::blocked_range<size_t>(i, i + faceChunkSize), CalculateGBCDImpl(i, numMisoReps, m_SurfaceMeshFaceLabelsPtr.lock(), m_SurfaceMeshFaceNormalsPtr.lock(), m_FeatureEulerAnglesPtr.lock(), m_FeaturePhasesPtr.lock(), m_CrystalStructuresPtr.lock(), m_GbcdBinsArray, m_GbcdHemiCheckArray, m_GbcdDeltasArray, m_GbcdSizesArray, m_GbcdLimitsArray), tbb::auto_partitioner()); } else #endif { CalculateGBCDImpl serial(i, numMisoReps, m_SurfaceMeshFaceLabelsPtr.lock(), m_SurfaceMeshFaceNormalsPtr.lock(), m_FeatureEulerAnglesPtr.lock(), m_FeaturePhasesPtr.lock(), m_CrystalStructuresPtr.lock(), m_GbcdBinsArray, m_GbcdHemiCheckArray, m_GbcdDeltasArray, m_GbcdSizesArray, m_GbcdLimitsArray); serial.generate(i, i + faceChunkSize); } currentMillis = QDateTime::currentMSecsSinceEpoch(); if (currentMillis - millis > 1000) { QString ss = QObject::tr("Calculating GBCD || Triangles %1/%2 Completed").arg(i).arg(totalFaces); timeDiff = ((float)i / (float)(currentMillis - startMillis)); estimatedTime = (float)(totalFaces - i) / timeDiff; ss = ss + QObject::tr(" || Est. Time Remain: %1").arg(DREAM3D::convertMillisToHrsMinSecs(estimatedTime)); millis = QDateTime::currentMSecsSinceEpoch(); notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss); } if(getCancel() == true) { return; } int32_t phase = 0; int32_t feature = 0; double area = 0.0; for (size_t j = 0; j < faceChunkSize; j++) { area = m_SurfaceMeshFaceAreas[i + j]; feature = m_SurfaceMeshFaceLabels[2 * (i + j)]; phase = m_FeaturePhases[feature]; for (size_t k = 0; k < numMisoReps; k++) { if (m_GbcdBins[(j * numMisoReps) + (k)] >= 0) { hemisphere = 0; if (m_HemiCheck[(j * numMisoReps) + k] == false) { hemisphere = 1; } m_GBCD[(phase * totalGBCDBins) + (2 * m_GbcdBins[(j * numMisoReps) + (k)] + hemisphere)] += area; totalFaceArea[phase] += area; } } } } ss = QObject::tr("Starting GBCD Normalization"); notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss); for (int32_t i = 0; i < totalPhases; i++) { size_t phaseShift = i * totalGBCDBins; double MRDfactor = double(totalGBCDBins) / totalFaceArea[i]; for (int32_t j = 0; j < totalGBCDBins; j++) { m_GBCD[phaseShift + j] *= MRDfactor; } } /* Let the GUI know we are done with this filter */ notifyStatusMessage(getHumanLabel(), "Complete"); }