void ItemBank::initialiseBank() {
DataStorage* dataStorage = dataStorage->getInstance();
strToBank(dataStorage->readFromLocalMemory());
return;
}
void FftClFft::
computeC2R( Tfr::ChunkData::Ptr input, DataStorage<float>::Ptr output )
{
unsigned denseWidth = input->size().width;
unsigned redundantWidth = output->size().width;
EXCEPTION_ASSERT( denseWidth == redundantWidth/2+1 );
Tfr::ChunkData::Ptr redundantInput( new Tfr::ChunkData( redundantWidth, input->size().height ));
{
Tfr::ChunkElement* in = CpuMemoryStorage::ReadOnly<1>( input ).ptr();
Tfr::ChunkElement* out = CpuMemoryStorage::WriteAll<1>( redundantInput ).ptr();
unsigned x;
for (x=0; x<denseWidth; ++x)
out[x] = in[x];
for (; x<redundantWidth; ++x)
out[x] = conj(in[redundantWidth - x]);
}
Tfr::ChunkData::Ptr complexoutput( new Tfr::ChunkData( output->size()));
computeWithClFft(redundantInput, complexoutput, FftDirection_Inverse);
::stftDiscardImag( complexoutput, output );
}
void FftClFft::
computeR2C( DataStorage<float>::Ptr input, Tfr::ChunkData::Ptr output )
{
unsigned denseWidth = output->size().width;
unsigned redundantWidth = input->size().width;
EXCEPTION_ASSERT( denseWidth == redundantWidth/2+1 );
// interleave input to complex data
Tfr::ChunkData::Ptr complexinput( new Tfr::ChunkData( input->size()));
::stftToComplex( input, complexinput );
// make room for full output
Tfr::ChunkData::Ptr redundantOutput( new Tfr::ChunkData( redundantWidth ));
// compute
computeWithClFft(complexinput, redundantOutput, FftDirection_Forward);
// discard redundant output
{
Tfr::ChunkElement* in = CpuMemoryStorage::ReadOnly<1>( redundantOutput ).ptr();
Tfr::ChunkElement* out = CpuMemoryStorage::WriteAll<1>( output ).ptr();
unsigned x;
for (x=0; x<denseWidth; ++x)
out[x] = in[x];
}
}
void FftClFft::
compute(DataStorage<float>::Ptr input, Tfr::ChunkData::Ptr output, DataStorageSize n )
{
unsigned denseWidth = n.width/2+1;
EXCEPTION_ASSERT( output->numberOfElements()/denseWidth == n.height );
EXCEPTION_ASSERT( input->numberOfElements()/n.width == n.height );
// interleave input to complex data
Tfr::ChunkData::Ptr complexinput( new Tfr::ChunkData( input->size()));
::stftToComplex( input, complexinput );
// make room for full output
Tfr::ChunkData::Ptr redundantOutput( new Tfr::ChunkData( n.width*n.height ));
// compute
computeWithClFft(complexinput, redundantOutput, n, FftDirection_Forward);
// discard redundant output
Tfr::ChunkElement* in = CpuMemoryStorage::ReadOnly<1>( redundantOutput ).ptr();
Tfr::ChunkElement* out = CpuMemoryStorage::WriteAll<1>( output ).ptr();
#pragma omp parallel for
for (int i=0; i < (int)n.height; ++i)
{
unsigned x;
for (x=0; x<denseWidth; ++x)
out[i*denseWidth + x] = in[i*n.width + x];
}
}
std::string DataStorageString::
printDataStorage(DataStorage<float>::ptr data)
{
EXCEPTION_ASSERT(data);
std::stringstream ss;
DataStorageSize sz = data->size ();
ss << sz;
float *p = sz.width ? data->getCpuMemory () : 0;
if (sz.depth>1) {
for (int z=0; z<sz.depth; ++z) {
for (int y=0; y<sz.height; ++y) {
ss << std::endl << "[z:" << z << ", y:" << y << "] = { ";
float *q = p + y*sz.width + z*sz.height*sz.width;
if (sz.width)
ss << q[0];
for (int x=1; x<sz.width; ++x)
ss << ", " << q[x];
ss << " }";
}
}
} else if (sz.height>1) {
for (int y=0; y<sz.height; ++y) {
ss << std::endl << "[y:" << y << "] = { ";
float *q = p + y*sz.width;
if (sz.width)
ss << q[0];
for (int x=1; x<sz.width; ++x)
ss << ", " << q[x];
ss << " }";
}
} else {
ss << " = { ";
if (sz.width)
ss << p[0];
for (int x=1; x<sz.width; ++x)
ss << ", " << p[x];
ss << " }";
}
return ss.str ();
}
void mitk::PickingTool::Activated()
{
DataStorage* dataStorage = this->GetDataStorage();
m_WorkingData = this->GetWorkingData();
//add to datastorage and enable interaction
if (!dataStorage->Exists(m_PointSetNode))
dataStorage->Add(m_PointSetNode, m_WorkingData);
// now add result to data tree
dataStorage->Add(m_ResultNode, m_WorkingData);
}
void ItemBank::update() {
vector<string>items;
for (vector<Item*>::iterator iter = bank.begin(); iter != bank.end(); iter++) {
items = updateItem(items, *iter);
}
DataStorage* dataStorage = dataStorage->getInstance();
dataStorage->writeToFile(items);
return;
}
TEST(typed_condition_test, bool_testing)
{
DataStorage tmp;
string k1 = "x";
string k2 = "y";
tmp.set_value(k1, false);
tmp.set_value(k2, true);
TypedCondition<bool> cond(&tmp,k1, true, Operation::EQUAL);
ASSERT_EQ(cond.evaluate(), false);
tmp.set_value(k1, true);
TypedCondition<bool> cond2(&tmp,k1, true, Operation::EQUAL);
ASSERT_EQ(cond2.evaluate(), true);
}
TEST(double_var_condition_test, float_testing)
{
DataStorage tmp;
string k1 = "x";
string k2 = "y";
tmp.set_value(k1, 10.0f);
tmp.set_value(k2, 20.12f);
DoubleVarCondition<float> cond(&tmp,k1, k2, Operation::GREATHER);
ASSERT_EQ(cond.evaluate(), false);
tmp.set_value(k1, 2.2f);
tmp.set_value(k2, 0.2f);
DoubleVarCondition<float> cond2(&tmp,k1, k2, Operation::LESS);
ASSERT_EQ(cond2.evaluate(), false);
tmp.set_value(k1, -0.2f);
tmp.set_value(k2, 999.2f);
DoubleVarCondition<float> cond3(&tmp,k1, k2, Operation::EQUAL);
ASSERT_EQ(cond3.evaluate(), false);
tmp.set_value(k1, 13.2f);
tmp.set_value(k2, 13.0f);
DoubleVarCondition<float> cond4(&tmp,k1, k2, Operation::EQUAL);
DoubleVarCondition<float> cond5(&tmp,k1, k2, Operation::GREATHEREQUAL);
DoubleVarCondition<float> cond6(&tmp,k1, k2, Operation::LESSEQUAL);
ASSERT_EQ(cond4.evaluate(), false);
ASSERT_EQ(cond5.evaluate(), true);
ASSERT_EQ(cond6.evaluate(), false);
}
TEST(double_var_condition_test, mixed)
{
DataStorage tmp;
string k1 = "x";
string k2 = "y";
tmp.set_value(k1, 10.0f);
tmp.set_value(k2, 20.0f);
DoubleVarCondition<float> cond(&tmp,k1, k2, Operation::GREATHER);
ASSERT_EQ(cond.evaluate(), false);
tmp.set_value(k1, 0);
tmp.set_value(k2, 0);
DoubleVarCondition<int> cond2(&tmp,k1, k2, Operation::EQUAL);
DoubleVarCondition<int> cond3(&tmp,k1, k2, Operation::LESS);
ASSERT_EQ(cond2.evaluate(), true);
ASSERT_EQ(cond3.evaluate(), false);
}
std::string DataStorageString::
printDataStorageStats(DataStorage<float>::ptr data)
{
std::stringstream ss;
Statistics<float> s(data, false, true);
ss << "size = " << data->size () << ", min = " << *s.getMin () << ", max = " << *s.getMax ()
<< ", mean = " << s.getMean () << ", std = " << s.getStd ();
return ss.str();
}
void EIDTag_Processor::process( const XMLCh* const chars
, const unsigned int length
, DataStorage& dataStorage
)
{
displayName();
//-------------------------------------
// if the current path matches what we have to save, copy over the data
// to the data storage
//-------------------------------------
if (dataStorage.matchTagPath())
{
char* pChars = XMLString::transcode(chars);
CByteArray* pData = new CByteArray(pChars);
XMLString::release(&pChars);
dataStorage.store(dataStorage.getTagPath(), pData);
}
}
void mitk::LiveWireTool2D::RemoveHelperObjects()
{
DataStorage *dataStorage = m_ToolManager->GetDataStorage();
if (!m_EditingContours.empty())
std::for_each(m_EditingContours.begin(), m_EditingContours.end(), RemoveFromDataStorage(dataStorage));
if (!m_WorkingContours.empty())
std::for_each(m_WorkingContours.begin(), m_WorkingContours.end(), RemoveFromDataStorage(dataStorage));
if (m_EditingContourNode.IsNotNull())
dataStorage->Remove(m_EditingContourNode);
if (m_LiveWireContourNode.IsNotNull())
dataStorage->Remove(m_LiveWireContourNode);
if (m_ContourModelNode.IsNotNull())
dataStorage->Remove(m_ContourModelNode);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void FftClFft::
inverse(Tfr::ChunkData::Ptr input, DataStorage<float>::Ptr output, DataStorageSize n )
{
unsigned denseWidth = n.width/2+1;
unsigned redundantWidth = n.width;
unsigned batchcount1 = output->numberOfElements()/redundantWidth,
batchcount2 = input->numberOfElements()/denseWidth;
EXCEPTION_ASSERT( batchcount1 == batchcount2 );
EXCEPTION_ASSERT( (denseWidth-1)*2 == redundantWidth );
EXCEPTION_ASSERT( redundantWidth*n.height == output->numberOfElements() );
Tfr::ChunkData::Ptr redundantInput( new Tfr::ChunkData( n.height*redundantWidth ));
{
Tfr::ChunkElement* in = CpuMemoryStorage::ReadOnly<1>( input ).ptr();
Tfr::ChunkElement* out = CpuMemoryStorage::WriteAll<1>( redundantInput ).ptr();
#pragma omp parallel for
for (int i=0; i < (int)n.height; ++i)
{
unsigned x;
for (x=0; x<denseWidth; ++x)
out[i*redundantWidth + x] = in[i*denseWidth + x];
for (; x<redundantWidth; ++x)
out[i*redundantWidth + x] = conj(in[i*denseWidth + redundantWidth - x]);
}
}
Tfr::ChunkData::Ptr complexoutput( new Tfr::ChunkData( output->size()));
computeWithClFft(redundantInput, complexoutput, DataStorageSize( redundantWidth, n.height), FftDirection_Inverse);
::stftDiscardImag( complexoutput, output );
TIME_STFT ComputationSynchronize();
}
DataStorage::SetOfObjects::Pointer AbstractFileReader::Read(DataStorage& ds)
{
DataStorage::SetOfObjects::Pointer result = DataStorage::SetOfObjects::New();
std::vector<BaseData::Pointer> data = this->Read();
for (std::vector<BaseData::Pointer>::iterator iter = data.begin();
iter != data.end(); ++iter)
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(*iter);
this->SetDefaultDataNodeProperties(node, this->GetInputLocation());
ds.Add(node);
result->InsertElement(result->Size(), node);
}
return result;
}
void mitk::PickingTool::OnPointAdded()
{
if (m_WorkingData != this->GetWorkingData())
{
DataStorage *dataStorage = this->GetDataStorage();
if (dataStorage->Exists(m_PointSetNode))
{
dataStorage->Remove(m_PointSetNode);
dataStorage->Add(m_PointSetNode, this->GetWorkingData());
}
if (dataStorage->Exists(m_ResultNode))
{
dataStorage->Remove(m_ResultNode);
dataStorage->Add(m_ResultNode, this->GetWorkingData());
}
m_WorkingData = this->GetWorkingData();
}
// Perform region growing/picking
int timeStep =
mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))->GetTimeStep();
mitk::PointSet::PointType seedPoint = m_PointSet->GetPointSet(timeStep)->GetPoints()->Begin().Value();
// as we want to pick a region from our segmentation image use the working data from ToolManager
mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image *>(m_ToolManager->GetWorkingData(0)->GetData());
if (orgImage.IsNotNull())
{
if (orgImage->GetDimension() == 4)
{ // there may be 4D segmentation data even though we currently don't support that
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(orgImage);
timeSelector->SetTimeNr(timeStep);
timeSelector->UpdateLargestPossibleRegion();
mitk::Image *timedImage = timeSelector->GetOutput();
AccessByItk_2(timedImage, StartRegionGrowing, timedImage->GetGeometry(), seedPoint);
}
else if (orgImage->GetDimension() == 3)
{
AccessByItk_2(orgImage, StartRegionGrowing, orgImage->GetGeometry(), seedPoint);
}
this->m_PointSet->Clear();
}
}
void MainWindow::saveClicked()
{
DataStorage storage;
QString filename = QFileDialog::getSaveFileName(this,
tr("Save File..."),
QString(), tr("Plot files (*.plot);;All Files (*)"));
if(!filename.isEmpty()) {
storage.setFunctionIndex(_plotControlWidget->getSelectedFunctionIndex());
storage.setFunctionParams(_plotControlWidget->getFunctionParameters());
storage.setValueFrom(_plotControlWidget->getValueFrom());
storage.setValueTo(_plotControlWidget->getValueTo());
storage.setStep(_plotControlWidget->getValueStep());
storage.setPoints(_points->getPoints());
if(!storage.save(filename)) {
QMessageBox::warning(this, "Warning!", "Could not save file with results!");
}\
}
}
int CoreDataNodeReader::Read(const std::string &fileName, DataStorage &storage)
{
mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
// the ITK Nrrd file reader cannot handle '/' in file path on Win 64bit
std::string name(fileName);
std::replace(name.begin(), name.end(), '\\', '/');
nodeReader->SetFileName(name);
nodeReader->Update();
int n = 0;
for ( unsigned int i = 0 ; i < nodeReader->GetNumberOfOutputs( ); ++i )
{
mitk::DataNode::Pointer node;
node = nodeReader->GetOutput(i);
if ( node->GetData() != NULL )
{
storage.Add(node);
++n;
}
}
return n;
}
void TaskAdder::executeCommand(Identifier infoIdentifier, DataStorage &dataStorage) {
//extract necessary information to create a new task
string date = infoIdentifier.getDate();
string startTime = infoIdentifier.getStartTime();
string endTime = infoIdentifier.getEndTime();
string event = infoIdentifier.getEvent();
string status = UNDONE; //defacult status of all status are undone
int index = dataStorage.getTaskIndex();
Task taskToAdd(event, date, startTime, endTime, UNDONE, index);
dataStorage.saveData(taskToAdd);
dataStorage.saveFile();
//increase the running index in dataStorage by 1 as one new task is added
dataStorage.setTaskIndex(dataStorage.getTaskIndex() + 1);
//display all the tasks of the same date on the task sheet
dataStorage.searchDate(date);
}
int main(int argc, char *argv[])
{
int sockfd, portno, n;
struct sockaddr_in serv_addr;
struct hostent *server;
//int32_t info[2];
//char buffer[256];
if (argc < 3) {
fprintf(stderr,"usage %s hostname port\n", argv[0]);
exit(0);
}
portno = atoi(argv[2]);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
error("ERROR opening socket");
server = gethostbyname(argv[1]);
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
error("ERROR connecting");
printf("Connection Successful! ");
//printf("Please enter the message: ");
//bzero(buffer,256);
//fgets(buffer,255,stdin);
//n = write(sockfd,buffer,strlen(buffer));
CVBoardTypes BT = cvV2718;
CVAddressModifier AM = cvA24_U_DATA;
CVDataWidth DW = cvD16;
DataStorage dataStore;
//int32_t Data = 0;
int32_t Handle;
n = dataStore.CAENVME_Init(BT,0,0,&Handle,sockfd);
if(n != cvSuccess){
printf("Return value is not cvSuccess\n");
}
/*
n = dataStore.CAENVME_ReadCycle(Handle,0x1800B4,&Data,AM,DW,sockfd);
if(n != cvSuccess){
printf("Return value is not cvSuccess\n");
}
printf("Data: %x\n", Data);
*/
int l;
for(l=0;l<100000;l++){
int32_t Data = l;
printf("Sending Data! \n");
n = dataStore.CAENVME_WriteCycle(Handle,0x1800B4,&Data,AM,DW,sockfd);
if(n != cvSuccess){
printf("Return value is not cvSuccess\n");
}
//n = dataStore.CAENVME_Init(BT,2,3,&Data,sockfd);
//n = dataStore.CAENVME_End(Data,sockfd);
n = dataStore.CAENVME_ReadCycle(Handle,0x1800B4,&Data,AM,DW,sockfd);
if(n != cvSuccess){
printf("Return value is not cvSuccess\n");
}
if(Data != l){
error("The Data Value Does not match \n");
}
//if (n < 0)
// error("ERROR writing to socket");
//bzero(buffer,256);
//n = read(sockfd,info,sizeof(info));
// if (n < 0)
// error("ERROR reading from socket");
}
n = dataStore.CAENVME_End(Handle,sockfd);
if(n != cvSuccess){
printf("Return value is not cvSuccess\n");
}
usleep(10000);
printf("All the data has been sent, Closing Socket\n");
close(sockfd);
return 0;
}
void MainWindow::loadClicked()
{
DataStorage storage;
QString filename = QFileDialog::getOpenFileName(this,
tr("Open File..."),
QString(), tr("Plot files (*.plot);;All Files (*)"));
if(!filename.isEmpty()) {
if(!storage.load(filename)) {
QMessageBox::warning(this, "Warning!", "Could not load file with results!");
return;
}
if(!_plotControlWidget->setFunctionIndex(storage.getFunctionIndex())) {
QMessageBox::warning(this, "Warning!", "Invalid function index was loaded!");
return;
}
_plotControlWidget->setFunctionParameters(storage.getFunctionParams());
if(storage.getValueFrom() > storage.getValueTo()) {
QMessageBox::warning(this, "Warning!", "Invalid function values range was loaded! Begin value must be less or equal than end value");
return;
}
_plotBuilder->setRange(storage.getValueFrom(), storage.getValueTo());
_plotControlWidget->setValueFrom(storage.getValueFrom());
_plotControlWidget->setValueTo(storage.getValueTo());
if(storage.getStep() <= 0) {
QMessageBox::warning(this, "Warning!", "Invalid calculation step was loaded. It must be greater than zero");
return;
}
_plotBuilder->setStep(storage.getStep());
_plotControlWidget->setValueStep(storage.getStep());
_points->setPoints(storage.getPoints());
_pointsWidget->updatePage();
}
}
void TaskSearcher::executeCommand(Identifier infoIdentifier, DataStorage &dataStorage) {
string keyword = infoIdentifier.getKeyword();
dataStorage.searchData(keyword);
}
