void APalette::createSimpleMap(APalette *org)
{
//if(error()) return;
if(tooBig) return;
if(!org) {
#ifdef DEBUG_VERBOSE
dBug<<"NULL palette in remap!\n";
#endif // DEBUG_VERBOSE
return;
}
//if(org->error()) return;
if(org->tooBig) return;
if(getNumColors()!=org->getNumColors()) {
#ifdef DEBUG_VERBOSE
dBug<<"Can't createSimpleMap, palettes aren't same size...\n";
#endif // DEBUG_VERBOSE
return;
}
for(unsigned int o=0;o<getNumColors();o++) {
map[o]=(int)org->findBestColor(r[o],g[o],b[o]);
//printColor(o);
//org->printColor(map[o]);
}
//printMap();
}
void APalette::resetHistogram()
{
if(tooBig) return;
if(score) free(score);
score=(long *)malloc(sizeof(long)*getNumColors());
if(!score) {
#ifdef DEBUG_VERBOSE
dBug<<"Couldn't allocate a histogram!!!\n";
#endif // DEBUG_VERBOSE
return;
}
for(unsigned int t=0;t<getNumColors();t++) score[t]=0;
}
void NgonGeneralData::getDataProperty(int property, void **_pvData)
{
switch (property)
{
case NUM_ELEMENTS_ARRAY :
/* Not implemented yet */
// getNumElementsArray();
break;
case COORDINATES :
*_pvData = getData();
break;
case X_COORDINATES :
*_pvData = getDataX();
break;
case Y_COORDINATES :
*_pvData = getDataY();
break;
case Z_COORDINATES :
*_pvData = getDataZ();
break;
case COLORS :
*_pvData = getColors();
break;
case NUM_COLORS :
((int *) *_pvData)[0] = getNumColors();
break;
default :
NgonData::getDataProperty(property, _pvData);
}
}
void APalette::setColor(unsigned int index,unsigned int red, unsigned int green, unsigned int blue)
{
if(readOnly) return;
//if(error()) return;
if(tooBig) return;
if(index>getNumColors()) return;
r[index]=red&bitsMask; g[index]=green&bitsMask; b[index]=blue&bitsMask;
used[index]=true;
touch();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WritePoleFigure::setupFilterParameters()
{
FilterParameterVector parameters;
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Image Format");
parameter->setPropertyName("ImageFormat");
QVector<QString> choices;
choices.push_back("tif");
choices.push_back("bmp");
choices.push_back("png");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(IntFilterParameter::New("Lambert Image Size (Pixels)", "LambertSize", getLambertSize(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Number of Colors", "NumColors", getNumColors(), FilterParameter::Parameter));
{
ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New();
parameter->setHumanLabel("Image Layout");
parameter->setPropertyName("ImageLayout");
QVector<QString> choices;
choices.push_back("Horizontal");
choices.push_back("Vertical");
choices.push_back("Square");
parameter->setChoices(choices);
parameter->setCategory(FilterParameter::Parameter);
parameters.push_back(parameter);
}
parameters.push_back(StringFilterParameter::New("Image Prefix", "ImagePrefix", getImagePrefix(), FilterParameter::Parameter));
parameters.push_back(OutputPathFilterParameter::New("Output Path", "OutputPath", getOutputPath(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Image Size (Square Pixels)", "ImageSize", getImageSize(), FilterParameter::Parameter));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Float, 3, SIMPL::AttributeMatrixType::Cell, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Euler Angles", "CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Int32, 1, SIMPL::AttributeMatrixType::Cell, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Phases", "CellPhasesArrayPath", getCellPhasesArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Bool, 1, SIMPL::AttributeMatrixType::Cell, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Mask", "GoodVoxelsArrayPath", getGoodVoxelsArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(SeparatorFilterParameter::New("Cell Ensemble Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::UInt32, 1, SIMPL::AttributeMatrixType::CellEnsemble, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Crystal Structures", "CrystalStructuresArrayPath", getCrystalStructuresArrayPath(), FilterParameter::RequiredArray, req));
}
setFilterParameters(parameters);
}
void APalette::createEmptyMapAndHistogram()
{
resetHistogram();
for(unsigned int t=0;t<getNumColors();t++) score[t]=getNumColors();
if(map) {
#ifdef DEBUG_VERBOSE
dBug<<"Already a map!!!\n";
#endif // DEBUG_VERBOSE
free(map);
}
map=(int *)malloc(sizeof(int)*numColors);
if(!map) {
#ifdef DEBUG_VERBOSE
dBug<<"Couldn't alloc map array!\n";
#endif // DEBUG_VERBOSE
return;
}
histComputed=true;
makeMap();
}
void APalette::printMap()
{
//if(error()) return;
if(!map) {
#ifdef DEBUG_VERBOSE
dBug<<"No map! Can't print it!\n";
#endif // DEBUG_VERBOSE
return;
}
#ifdef DEBUG_VERBOSE
dBug<<"Map: ";
for(unsigned int o=0;o<getNumColors();o++) dBug<<map[o]<<" ";
dBug<<"\n";
#endif // DEBUG_VERBOSE
}
static size_t getBMPHeaderSize(BITMAPINFO* bmp)
{
return (bmp->bmiHeader.biSize + getNumColors(bmp)*sizeof(RGBQUAD));
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WritePoleFigure::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_CellPhasesArrayPath.getDataContainerName());
size_t dims[3] = { 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(dims);
// Make sure any directory path is also available as the user may have just typed
// in a path without actually creating the full path
QDir path(getOutputPath());
if (!path.mkpath(".") )
{
QString ss = QObject::tr("Error creating parent path '%1'").arg(path.absolutePath());
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
bool missingGoodVoxels = true;
if (NULL != m_GoodVoxels)
{
missingGoodVoxels = false;
}
// Find how many phases we have by getting the number of Crystal Structures
size_t numPoints = m->getGeometryAs<ImageGeom>()->getNumberOfElements();
size_t numPhases = m_CrystalStructuresPtr.lock()->getNumberOfTuples();
// Loop over all the voxels gathering the Eulers for a specific phase into an array
for (size_t phase = 1; phase < numPhases; ++phase)
{
size_t count = 0;
// First find out how many voxels we are going to have. This is probably faster to loop twice than to
// keep allocating memory everytime we find one.
for (size_t i = 0; i < numPoints; ++i)
{
if (m_CellPhases[i] == phase)
{
if (missingGoodVoxels == true || m_GoodVoxels[i] == true)
{
count++;
}
}
}
QVector<size_t> eulerCompDim(1, 3);
FloatArrayType::Pointer subEulers = FloatArrayType::CreateArray(count, eulerCompDim, "Eulers_Per_Phase");
subEulers->initializeWithValue(std::numeric_limits<float>::signaling_NaN());
float* eu = subEulers->getPointer(0);
// Now loop through the eulers again and this time add them to the subEulers Array
count = 0;
for (size_t i = 0; i < numPoints; ++i)
{
if (m_CellPhases[i] == phase)
{
if (missingGoodVoxels == true || m_GoodVoxels[i] == true)
{
eu[count * 3] = m_CellEulerAngles[i * 3];
eu[count * 3 + 1] = m_CellEulerAngles[i * 3 + 1];
eu[count * 3 + 2] = m_CellEulerAngles[i * 3 + 2];
count++;
}
}
}
if (subEulers->getNumberOfTuples() == 0) { continue; } // Skip because we have no Pole Figure data
QVector<UInt8ArrayType::Pointer> figures;
PoleFigureConfiguration_t config;
config.eulers = subEulers.get();
config.imageDim = getImageSize();
config.lambertDim = getLambertSize();
config.numColors = getNumColors();
QString label("Phase_");
label.append(QString::number(phase));
QString ss = QObject::tr("Generating Pole Figures for Phase %1").arg(phase);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
switch(m_CrystalStructures[phase])
{
case Ebsd::CrystalStructure::Cubic_High:
figures = makePoleFigures<CubicOps>(config);
break;
case Ebsd::CrystalStructure::Cubic_Low:
figures = makePoleFigures<CubicLowOps>(config);
break;
case Ebsd::CrystalStructure::Hexagonal_High:
figures = makePoleFigures<HexagonalOps>(config);
break;
case Ebsd::CrystalStructure::Hexagonal_Low:
figures = makePoleFigures<HexagonalLowOps>(config);
break;
case Ebsd::CrystalStructure::Trigonal_High:
// figures = makePoleFigures<TrigonalOps>(config);
notifyWarningMessage(getHumanLabel(), "Trigonal High Symmetry is not supported for Pole figures. This phase will be omitted from results", -1010);
break;
case Ebsd::CrystalStructure::Trigonal_Low:
// figures = makePoleFigures<TrigonalLowOps>(config);
notifyWarningMessage(getHumanLabel(), "Trigonal Low Symmetry is not supported for Pole figures. This phase will be omitted from results", -1010);
break;
case Ebsd::CrystalStructure::Tetragonal_High:
// figures = makePoleFigures<TetragonalOps>(config);
notifyWarningMessage(getHumanLabel(), "Tetragonal High Symmetry is not supported for Pole figures. This phase will be omitted from results", -1010);
break;
case Ebsd::CrystalStructure::Tetragonal_Low:
// figures = makePoleFigures<TetragonalLowOps>(config);
notifyWarningMessage(getHumanLabel(), "Tetragonal Low Symmetry is not supported for Pole figures. This phase will be omitted from results", -1010);
break;
case Ebsd::CrystalStructure::OrthoRhombic:
figures = makePoleFigures<OrthoRhombicOps>(config);
break;
case Ebsd::CrystalStructure::Monoclinic:
figures = makePoleFigures<MonoclinicOps>(config);
break;
case Ebsd::CrystalStructure::Triclinic:
figures = makePoleFigures<TriclinicOps>(config);
break;
default:
break;
}
if (figures.size() == 3)
{
QImage combinedImage = PoleFigureImageUtilities::Create3ImagePoleFigure(figures[0].get(), figures[1].get(), figures[2].get(), config, getImageLayout());
writeImage(combinedImage, label);
}
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
