// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void readPipeline(QFilterParametersReader::Pointer paramsReader, FilterPipeline::Pointer pipeline)
{
FilterManager* filtManager = FilterManager::Instance();
QSettings* prefs = paramsReader->getPrefs();
prefs->beginGroup(DREAM3D::Settings::PipelineBuilderGroup);
bool ok = false;
int filterCount = prefs->value("Number_Filters").toInt(&ok);
prefs->endGroup();
if (false == ok) {filterCount = 0;}
for (int i = 0; i < filterCount; ++i)
{
QString gName = QString::number(i);
// Open the group to get the name of the filter then close again.
prefs->beginGroup(gName);
QString filterName = prefs->value("Filter_Name", "").toString();
prefs->endGroup();
// qDebug() << filterName;
IFilterFactory::Pointer factory = filtManager->getFactoryForFilter(filterName);
AbstractFilter::Pointer filter = factory->create();
if(NULL != filter.get())
{
filter->readFilterParameters(paramsReader.get(), i);
pipeline->pushBack(filter);
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void LoopOnFilters()
{
FilterManager::Pointer fm = FilterManager::Instance();
FilterManager::Collection factories = fm->getFactories();
FilterManager::CollectionIterator i(factories);
int count = 0;
while (i.hasNext())
{
i.next();
std::cout << ++count << ": " << i.key().toStdString() << ": " << std::endl;
//std::cout << " public:" << std::endl;
IFilterFactory::Pointer factory = i.value();
AbstractFilter::Pointer filter = factory->create();
//if (filter->getGroupName().compare(DREAM3D::FilterGroups::StatisticsFilters) == 0)
// if(filter->getNameOfClass().compare("FindSchmids") == 0)
{
// std::cout << "" << filter->getGroupName().toStdString() << "Filters/" << filter->getNameOfClass().toStdString() << ".cpp" << std::endl;
QString cpp = findPath(filter->getGroupName(), filter->getNameOfClass(), ".cpp");
std::cout << filter << " " << cpp.toStdString() << std::endl;
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
AbstractFilter::Pointer InstantiateFilter(QString filtName)
{
// Now instantiate the PhWriter Filter from the FilterManager
FilterManager* fm = FilterManager::Instance();
IFilterFactory::Pointer filterFactory = fm->getFactoryForFilter(filtName);
if (NULL == filterFactory.get() )
{
std::stringstream ss;
ss << "The OrientationTransformTest Requires the use of the " << filtName.toStdString() << " filter. Did the plugins load?";
DREAM3D_TEST_THROW_EXCEPTION(ss.str())
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int TestFilterAvailability()
{
// Now instantiate the PhWriter Filter from the FilterManager
QString filtName = "PhWriter";
FilterManager* fm = FilterManager::Instance();
IFilterFactory::Pointer filterFactory = fm->getFactoryForFilter(filtName);
if (NULL == filterFactory.get() )
{
std::stringstream ss;
ss << "The PhIOTest Requires the use of the " << filtName.toStdString() << " filter which is found in the IO Plugin";
DREAM3D_TEST_THROW_EXCEPTION(ss.str())
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int TestFilterAvailability()
{
// Now instantiate the ReadCtfData Filter from the FilterManager
QString filtName = "ReadCtfData";
FilterManager* fm = FilterManager::Instance();
IFilterFactory::Pointer filterFactory = fm->getFactoryForFilter(filtName);
if (NULL == filterFactory.get())
{
std::stringstream ss;
ss << "The CtfCachingTest requires the use of the " << filtName.toStdString() << " filter which is found in the OrientationAnalysis Plugin";
DREAM3D_TEST_THROW_EXCEPTION(ss.str())
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int TestFilterAvailability()
{
// Now instantiate the FindDifferenceMapTest Filter from the FilterManager
QString filtName = "ConditionalSetValue";
FilterManager* fm = FilterManager::Instance();
IFilterFactory::Pointer filterFactory = fm->getFactoryForFilter(filtName);
if (NULL == filterFactory.get())
{
std::stringstream ss;
ss << "The ConditionalSetValueTest Requires the use of the " << filtName.toStdString() << " filter which is found in Core Filters";
DREAM3D_TEST_THROW_EXCEPTION(ss.str())
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void PipelineViewEntry::instantiateFilter(const QString& filterClassName)
{
FilterManager::Pointer fm = FilterManager::Instance();
if(NULL == fm.get() ) { return; }
IFilterFactory::Pointer ff = fm->getFactoryForFilter(filterClassName);
if (NULL == ff.get()) { return; }
// Create an instance of the filter. Since we are dealing with the AbstractFilter interface we can not
// actually use the actual filter class. We are going to have to rely on QProperties or Signals/Slots
// to communicate changes back to the filter.
m_Filter = ff->create();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int DataContainerReader::readExistingPipelineFromFile(hid_t fileId)
{
herr_t err = 0;
m_PipelineFromFile->clear();
H5FilterParametersReader::Pointer reader = H5FilterParametersReader::New();
// HDF5: Open the "Pipeline" Group
hid_t pipelineGroupId = H5Gopen(fileId, DREAM3D::StringConstants::PipelineGroupName.toLatin1().data(), H5P_DEFAULT);
reader->setPipelineGroupId(pipelineGroupId);
// Use QH5Lite to ask how many "groups" are in the "Pipeline Group"
QList<QString> groupList;
err = QH5Utilities::getGroupObjects(pipelineGroupId, H5Utilities::H5Support_GROUP, groupList);
// Loop over the items getting the "ClassName" attribute from each group
QString classNameStr = "";
for (int32_t i = 0; i < groupList.size(); i++)
{
QString ss = QString::number(i, 10);
err = QH5Lite::readStringAttribute(pipelineGroupId, ss, "ClassName", classNameStr);
if (err < 0)
{
qDebug() << "Filter Index = " << i;
}
// Instantiate a new filter using the FilterFactory based on the value of the className attribute
FilterManager* fm = FilterManager::Instance();
IFilterFactory::Pointer ff = fm->getFactoryForFilter(classNameStr);
if (NULL != ff.get())
{
AbstractFilter::Pointer filter = ff->create();
if (NULL != filter.get())
{
// Read the parameters
filter->readFilterParameters( reader.get(), i);
// Add filter to m_PipelineFromFile
m_PipelineFromFile->pushBack(filter);
}
}
}
err = H5Gclose(pipelineGroupId);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateFilterParametersCode()
{
FilterManager::Pointer fm = FilterManager::Instance();
FilterManager::Collection factories = fm->getFactories();
QMapIterator<QString, IFilterFactory::Pointer> iter(factories);
// Loop on each filter
while(iter.hasNext())
{
iter.next();
IFilterFactory::Pointer factory = iter.value();
AbstractFilter::Pointer filter = factory->create();
QString cpp = findPath(filter->getGroupName(), filter->getNameOfClass(), ".cpp");
QString h = findPath(filter->getGroupName(), filter->getNameOfClass(), ".h");
fixFile(filter, h, cpp);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateMatlabCode(const QString& outDir)
{
// Sanity check to make sure we have our output directory:
QDir dir(outDir);
dir.mkpath(".");
// Get the FilterManager which will have a list of ALL of our
FilterManager* fm = FilterManager::Instance();
FilterManager::Collection factories = fm->getFactories();
QMapIterator<QString, IFilterFactory::Pointer> iter(factories);
// Loop on each filter
while(iter.hasNext())
{
iter.next();
IFilterFactory::Pointer factory = iter.value();
AbstractFilter::Pointer filter = factory->create();
GenerateCodeForFilter(outDir, filter);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
FilterPipeline::Pointer JsonFilterParametersReader::ReadPipelineFromFile(QString filePath, IObserver* obs)
{
QFileInfo fInfo(filePath);
if (filePath.isEmpty() == true)
{
return FilterPipeline::NullPointer();
}
QFileInfo fi(filePath);
if (fi.exists() == false)
{
return FilterPipeline::NullPointer();
}
FilterManager* filtManager = FilterManager::Instance();
FilterFactory<EmptyFilter>::Pointer emptyFilterFactory = FilterFactory<EmptyFilter>::New();
filtManager->addFilterFactory("EmptyFilter", emptyFilterFactory);
JsonFilterParametersReader::Pointer reader = JsonFilterParametersReader::New();
int err = reader->openFile(filePath);
if (err < 0)
{
if (NULL != obs)
{
PipelineMessage pm(JsonFilterParametersReader::ClassName(), "File '" + fInfo.fileName() + "' could not be opened for reading.", -1, PipelineMessage::Error);
obs->processPipelineMessage(pm);
}
return FilterPipeline::NullPointer();
}
reader->openGroup(DREAM3D::Settings::PipelineBuilderGroup);
int filterCount = reader->readValue(DREAM3D::Settings::NumFilters, 0);
reader->closeGroup();
FilterPipeline::Pointer pipeline = FilterPipeline::New();
for (int i = 0; i < filterCount; ++i)
{
// Open the group to get the name of the filter then close again.
reader->openFilterGroup(NULL, i);
QString filterName = reader->readString(DREAM3D::Settings::FilterName, "");
reader->closeFilterGroup();
//qDebug() << "Group: " << gName << " FilterName: " << filterName;
if (filterName.isEmpty() == false)
{
IFilterFactory::Pointer factory = filtManager->getFactoryForFilter(filterName);
if (factory.get() != NULL)
{
AbstractFilter::Pointer filter = factory->create();
if (NULL != filter.get())
{
filter->readFilterParameters(reader.get(), i);
pipeline->pushBack(filter);
}
}
else // Could not find the filter because the specific name has not been registered. This could
// be due to a name change for the filter.
{
EmptyFilter::Pointer filter = EmptyFilter::New();
QString humanLabel = QString("UNKNOWN FILTER: ") + filterName;
filter->setHumanLabel(humanLabel);
filter->setOriginalFilterName(filterName);
pipeline->pushBack(filter);
if (NULL != obs)
{
QString ss = QObject::tr("An implementation for filter '%1' could not be located. Possible reasons include a name change of the filter, plugin not loading or a simple spelling mistake? A blank filter has been inserted in its place.").arg(filterName);
PipelineMessage pm(filterName, ss, -66066, PipelineMessage::Error);
pm.setPrefix("JsonFilterParametersReader::ReadPipelineFromFile()");
obs->processPipelineMessage(pm);
}
}
}
else
{
EmptyFilter::Pointer filter = EmptyFilter::New();
QString humanLabel = QString("MISSING FILTER: ") + filterName;
filter->setHumanLabel(humanLabel);
filter->setOriginalFilterName(filterName);
pipeline->pushBack(filter);
if (NULL != obs)
{
QString gName = QString::number(i);
QString ss = QObject::tr("A filter for index '%1' is missing in the file. Is the numbering of the filters correct in the pipeline file?").arg(gName);
PipelineMessage pm(filterName, ss, -66067, PipelineMessage::Error);
pm.setPrefix("JsonFilterParametersReader::ReadPipelineFromFile()");
obs->processPipelineMessage(pm);
}
}
}
return pipeline;
}
