int main()
{
clock_t time = clock();
IFileReader* reader = new PokFileReader();
IFileWriter* writer = new FileWriter();
Helper* helper = new Helper(reader, writer);
std::vector<Patient> group1 = helper->ReadGroup("ALLD2", "D2", ".POK", 60);
std::vector<Patient> group2 = helper->ReadGroup("ALLD3", "D3", ".POK", 42);
IMeasureCalculator* measureCalculator = new PetuninMeasureCalculator();
Calculator* calculator = new Calculator(group1, group2, measureCalculator);
std::vector<std::vector<double>> averageMatrix = calculator->AverageMatrix(15);
averageMatrix = TransposeMatrix(averageMatrix);
writer->WriteMatrix("result.txt", averageMatrix);
delete calculator;
delete measureCalculator;
delete helper;
delete reader;
delete writer;
//Do stuff
time = clock() - time;
double ms = double(time) / CLOCKS_PER_SEC * 1000;
std::cout << "Finished!\nTime elapsed: " << ms << " ms" << std::endl;
std::cin.get();
return 0;
}
void MainWindow::saveFile()
{
QString ext = QFileInfo(m_canvasFile).suffix();
IFileWriter *writer = FileWriterFactory::create(ext.toStdString());
assert(writer != nullptr);
writer->setup(m_canvas->getMainGroup());
if (writer->write(m_canvasFile.toStdString())) {
ui->statusBar->showMessage(QString("Saved file: \"%1\"").arg(m_canvasFile));
} else {
QMessageBox::critical(this,
"File Write Error",
"I can't write to this file. Does it exist, and if so do you give me access to write to it?");
delete writer;
return;
}
setCommandStackIdx(m_mcs->getCurrentIdx());
mainCommandStackHasChanged();
delete writer;
}
FileWriterSelector::FileWriterSelector(const BaseData* baseData, const std::string& destMimeType)
: m_Data(new Impl)
{
mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
std::vector<std::string> classHierarchy = baseData->GetClassHierarchy();
// Get all writers and their mime types for the given base data type
std::vector<FileWriterRegistry::WriterReference> refs = m_Data->m_WriterRegistry.GetReferences(baseData, destMimeType);
us::ServiceReference<IFileWriter> bestRef;
for (std::vector<FileWriterRegistry::WriterReference>::const_iterator iter = refs.begin(),
iterEnd = refs.end(); iter != iterEnd; ++iter)
{
std::string mimeTypeName = iter->GetProperty(IFileWriter::PROP_MIMETYPE()).ToString();
if (!mimeTypeName.empty())
{
MimeType mimeType = mimeTypeProvider->GetMimeTypeForName(mimeTypeName);
if (mimeType.IsValid())
{
// There is a registered mime-type for this writer. Now get the confidence level
// of this writer for writing the given base data object.
IFileWriter* writer = m_Data->m_WriterRegistry.GetWriter(*iter);
if (writer == NULL) continue;
try
{
writer->SetInput(baseData);
IFileWriter::ConfidenceLevel confidenceLevel = writer->GetConfidenceLevel();
std::cout << confidenceLevel << std::endl;
if (confidenceLevel == IFileWriter::Unsupported)
{
continue;
}
std::string baseDataType = iter->GetProperty(IFileWriter::PROP_BASEDATA_TYPE()).ToString();
std::vector<std::string>::iterator idxIter =
std::find(classHierarchy.begin(), classHierarchy.end(), baseDataType);
std::size_t baseDataIndex = std::numeric_limits<std::size_t>::max();
if (idxIter != classHierarchy.end())
{
baseDataIndex = std::distance(classHierarchy.begin(), idxIter);
}
Item item;
item.d->m_FileWriterRef = *iter;
item.d->m_FileWriter = writer;
item.d->m_ConfidenceLevel = confidenceLevel;
item.d->m_BaseDataIndex = baseDataIndex;
item.d->m_MimeType = mimeType;
item.d->m_Id = us::any_cast<long>(iter->GetProperty(us::ServiceConstants::SERVICE_ID()));
m_Data->m_Items.insert(std::make_pair(item.d->m_Id, item));
m_Data->m_MimeTypes.insert(mimeType);
if (!bestRef || bestRef < *iter)
{
bestRef = *iter;
}
}
catch (const us::BadAnyCastException& e)
{
MITK_WARN << "Unexpected: " << e.what();
}
catch (const std::exception& e)
{
// Log the error but continue
MITK_WARN << "IFileWriter::GetConfidenceLevel exception: " << e.what();
}
}
}
}
if (bestRef)
{
try
{
m_Data->m_BestId = us::any_cast<long>(bestRef.GetProperty(us::ServiceConstants::SERVICE_ID()));
m_Data->m_SelectedId = m_Data->m_BestId;
} catch (const us::BadAnyCastException&) {}
}
}
FileWriterSelector::FileWriterSelector(const BaseData* baseData, const std::string& mimeType,
const std::string& path)
: m_Data(new Impl)
{
mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
std::string destMimeType = mimeType;
if (destMimeType.empty() && !path.empty())
{
// try to derive a mime-type from the file
std::vector<MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForFile(path);
if (!mimeTypes.empty())
{
destMimeType = mimeTypes.front().GetName();
}
else if (!itksys::SystemTools::GetFilenameExtension(path).empty())
{
// If there are no suitable mime-type for the file AND an extension
// was supplied, we stop here.
return;
}
}
std::vector<std::string> classHierarchy = baseData->GetClassHierarchy();
// Get all writers and their mime types for the given base data type
std::vector<FileWriterRegistry::WriterReference> refs = m_Data->m_WriterRegistry.GetReferences(baseData, destMimeType);
Item bestItem;
for (std::vector<FileWriterRegistry::WriterReference>::const_iterator iter = refs.begin(),
iterEnd = refs.end(); iter != iterEnd; ++iter)
{
std::string mimeTypeName = iter->GetProperty(IFileWriter::PROP_MIMETYPE()).ToString();
if (!mimeTypeName.empty())
{
MimeType mimeType = mimeTypeProvider->GetMimeTypeForName(mimeTypeName);
if (mimeType.IsValid())
{
// There is a registered mime-type for this writer. Now get the confidence level
// of this writer for writing the given base data object.
IFileWriter* writer = m_Data->m_WriterRegistry.GetWriter(*iter);
if (writer == NULL) continue;
try
{
writer->SetInput(baseData);
IFileWriter::ConfidenceLevel confidenceLevel = writer->GetConfidenceLevel();
if (confidenceLevel == IFileWriter::Unsupported)
{
continue;
}
std::string baseDataType = iter->GetProperty(IFileWriter::PROP_BASEDATA_TYPE()).ToString();
std::vector<std::string>::iterator idxIter =
std::find(classHierarchy.begin(), classHierarchy.end(), baseDataType);
std::size_t baseDataIndex = std::numeric_limits<std::size_t>::max();
if (idxIter != classHierarchy.end())
{
baseDataIndex = std::distance(classHierarchy.begin(), idxIter);
}
Item item;
item.d->m_FileWriterRef = *iter;
item.d->m_FileWriter = writer;
item.d->m_ConfidenceLevel = confidenceLevel;
item.d->m_BaseDataIndex = baseDataIndex;
item.d->m_MimeType = mimeType;
item.d->m_Id = us::any_cast<long>(iter->GetProperty(us::ServiceConstants::SERVICE_ID()));
m_Data->m_Items.insert(std::make_pair(item.d->m_Id, item));
m_Data->m_MimeTypes.insert(mimeType);
if (!bestItem.GetReference() || bestItem < item)
{
bestItem = item;
}
}
catch (const us::BadAnyCastException& e)
{
MITK_WARN << "Unexpected: " << e.what();
}
catch (const std::exception& e)
{
// Log the error but continue
MITK_WARN << "IFileWriter::GetConfidenceLevel exception: " << e.what();
}
}
}
}
if (bestItem.GetReference())
{
m_Data->m_BestId = bestItem.GetServiceId();
m_Data->m_SelectedId = m_Data->m_BestId;
}
}
