// --------------------------------------------------------
LoadReadoutMenu::LoadReadoutMenu( const std::string& aId, swatch::core::ActionableObject& aActionable ) :
swatch::core::Command(aId, aActionable, xdata::UnsignedInteger())
{
::mp7::MP7Controller& lDriver = getActionable<MP7Processor>().driver();
const ::mp7::ReadoutCtrlNode& rc = lDriver.getReadout().getNode< ::mp7::ReadoutCtrlNode>("readout_control");
mBanks = rc.readNumBanks();
mModes = rc.readNumModes();
mCaptures = rc.readNumCaptures();
std::string bankStr, modeStr, capStr;
for( uint32_t iB(0); iB < mBanks; ++iB ) {
bankStr = "bank"+boost::lexical_cast<std::string>(iB)+":";
registerParameter(bankStr+"wordsPerBx", xdata::UnsignedInteger());
}
for( uint32_t iM(0); iM < mModes; ++iM ) {
modeStr = "mode"+boost::lexical_cast<std::string>(iM)+":";
registerParameter(modeStr+"eventSize", xdata::UnsignedInteger());
registerParameter(modeStr+"eventToTrigger", xdata::UnsignedInteger());
registerParameter(modeStr+"eventType", xdata::UnsignedInteger());
registerParameter(modeStr+"tokenDelay", xdata::UnsignedInteger());
for( uint32_t iC(0); iC < mCaptures; ++iC ) {
capStr = modeStr+"capture"+boost::lexical_cast<std::string>(iC)+":";
registerParameter(capStr+"enable", xdata::Boolean());
registerParameter(capStr+"id", xdata::UnsignedInteger());
registerParameter(capStr+"bankId", xdata::UnsignedInteger());
registerParameter(capStr+"length", xdata::UnsignedInteger());
registerParameter(capStr+"delay", xdata::UnsignedInteger());
registerParameter(capStr+"readoutLength", xdata::UnsignedInteger());
}
}
}
ITK_THREAD_RETURN_TYPE ThreadMethod(void *data)
{
/* extract data pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct *pInfo = (struct itk::MultiThreader::ThreadInfoStruct *)data;
// some data validity checking
if (pInfo == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == NULL)
{
return ITK_THREAD_RETURN_VALUE;
}
// obtain user data for processing
ThreadData *threadData = (ThreadData *)pInfo->UserData;
srand(pInfo->ThreadID);
mitk::Image::Pointer im = threadData->data;
int nrSlices = im->GetDimension(2);
// Create randomly a PixelRead- or PixelWriteAccessor for a slice and access all pixels in it.
try
{
if (rand() % 2)
{
testMutex.Lock();
mitk::ImageDataItem *iDi = im->GetSliceData(rand() % nrSlices);
testMutex.Unlock();
while (!iDi->IsComplete())
{
}
// MITK_INFO << "pixeltype: " << im->GetPixelType().GetComponentTypeAsString();
if ((im->GetPixelType().GetComponentTypeAsString() == "short") && (im->GetDimension() == 3))
{
// Use pixeltype&dimension specific read accessor
int xlength = im->GetDimension(0);
int ylength = im->GetDimension(1);
mitk::ImagePixelReadAccessor<short, 2> readAccessor(im, iDi);
itk::Index<2> idx;
for (int i = 0; i < xlength; ++i)
{
for (int j = 0; j < ylength; ++j)
{
idx[0] = i;
idx[1] = j;
readAccessor.GetPixelByIndexSafe(idx);
}
}
}
else
{
// use general accessor
mitk::ImageReadAccessor *iRA = new mitk::ImageReadAccessor(im, iDi);
delete iRA;
}
}
else
{
testMutex.Lock();
mitk::ImageDataItem *iDi = im->GetSliceData(rand() % nrSlices);
testMutex.Unlock();
while (!iDi->IsComplete())
{
}
if ((im->GetPixelType().GetComponentTypeAsString() == "short") && (im->GetDimension() == 3))
{
// Use pixeltype&dimension specific read accessor
int xlength = im->GetDimension(0);
int ylength = im->GetDimension(1);
mitk::ImagePixelWriteAccessor<short, 2> writeAccessor(im, iDi);
itk::Index<2> idx;
for (int i = 0; i < xlength; ++i)
{
for (int j = 0; j < ylength; ++j)
{
idx[0] = i;
idx[1] = j;
short newVal = rand() % 16000;
writeAccessor.SetPixelByIndexSafe(idx, newVal);
short val = writeAccessor.GetPixelByIndexSafe(idx);
if (val != newVal)
{
threadData->m_Successful = false;
}
}
}
}
else
{
// use general accessor
mitk::ImageWriteAccessor iB(im, iDi);
void *pointer = iB.GetData();
*((char *)pointer) = 0;
}
}
}
catch (mitk::MemoryIsLockedException &e)
{
threadData->m_Successful = false;
e.Print(std::cout);
}
catch (mitk::Exception &e)
{
threadData->m_Successful = false;
e.Print(std::cout);
}
// data processing end!
threadData->m_Barrier->Wait();
return ITK_THREAD_RETURN_VALUE;
}
// --------------------------------------------------------
core::Command::State
LoadReadoutMenu::code(const ::swatch::core::XParameterSet& aParams)
{
::mp7::ReadoutMenu lMenu(mBanks, mModes, mCaptures);
// Bank IDs
std::string bankStr, modeStr, capStr;
for( uint32_t iB(0); iB < mBanks; ++iB ) {
bankStr = "bank"+boost::lexical_cast<std::string>(iB)+":";
const xdata::UnsignedInteger& bxOffset = aParams.get<xdata::UnsignedInteger>(bankStr+"wordsPerBx");
if ( !bxOffset.isNaN()) lMenu.bank(iB).wordsPerBx = bxOffset.value_;
}
for( uint32_t iM(0); iM < mModes; ++iM ) {
modeStr = "mode"+boost::lexical_cast<std::string>(iM)+":";
const xdata::UnsignedInteger& eventSize = aParams.get<xdata::UnsignedInteger>(modeStr+"eventSize");
const xdata::UnsignedInteger& eventToTrigger = aParams.get<xdata::UnsignedInteger>(modeStr+"eventToTrigger");
const xdata::UnsignedInteger& eventType = aParams.get<xdata::UnsignedInteger>(modeStr+"eventType");
const xdata::UnsignedInteger& tokenDelay = aParams.get<xdata::UnsignedInteger>(modeStr+"tokenDelay");
::mp7::ReadoutMenu::Mode& lMode = lMenu.mode(iM);
if ( !eventSize.isNaN()) lMode.eventSize = eventSize.value_;
if ( !eventToTrigger.isNaN()) lMode.eventToTrigger = eventToTrigger.value_;
if ( !eventType.isNaN()) lMode.eventType = eventType.value_;
if ( !tokenDelay.isNaN()) lMode.tokenDelay = tokenDelay.value_;
LOG(swatch::logger::kWarning) << lMode;
for( uint32_t iC(0); iC < mCaptures; ++iC ) {
capStr = modeStr+"capture"+boost::lexical_cast<std::string>(iC)+":";
const xdata::Boolean& enable = aParams.get<xdata::Boolean>(capStr+"enable");
const xdata::UnsignedInteger& id = aParams.get<xdata::UnsignedInteger>(capStr+"id");
const xdata::UnsignedInteger& bankId = aParams.get<xdata::UnsignedInteger>(capStr+"bankId");
const xdata::UnsignedInteger& length = aParams.get<xdata::UnsignedInteger>(capStr+"length");
const xdata::UnsignedInteger& delay = aParams.get<xdata::UnsignedInteger>(capStr+"delay");
const xdata::UnsignedInteger& readoutLength = aParams.get<xdata::UnsignedInteger>(capStr+"readoutLength");
::mp7::ReadoutMenu::Capture& lCapture = lMode[iC];
if ( !enable.isNaN()) lCapture.enable = enable.value_;
if ( !id.isNaN()) lCapture.id = id.value_;
if ( !bankId.isNaN()) lCapture.bankId = bankId.value_;
if ( !length.isNaN()) lCapture.length = length.value_;
if ( !delay.isNaN()) lCapture.delay = delay.value_;
if ( !readoutLength.isNaN()) lCapture.readoutLength = readoutLength.value_;
}
}
::mp7::MP7Controller& driver = getActionable<MP7Processor>().driver();
const ::mp7::ReadoutCtrlNode& rc = driver.getReadout().getNode< ::mp7::ReadoutCtrlNode >("readout_control");
std::map<uint32_t,uint32_t> lEventSizes = driver.computeEventSizes(lMenu);
for( uint32_t iM(0); iM < mModes; ++iM ) {
::mp7::ReadoutMenu::Mode& lMode = lMenu.mode(iM);
if ( lMode.eventSize == 0xfffff ) continue;
lMode.eventSize = lEventSizes.at(iM);
LOG(swatch::logger::kInfo) << "Mode " << iM << " event size set to " << lMode.eventSize;
}
LOG(swatch::logger::kInfo) << lMenu;
rc.configureMenu(lMenu);
return State::kDone;
}
virtual void init(Voxel& voxel)
{
b0_index.clear();
for(unsigned int index = 0;index < voxel.bvalues.size();++index)
if(voxel.bvalues[index] == 0)
b0_index.push_back(index);
half_odf_size = voxel.ti.vertices_count/2;
float lambda = voxel.param[0];
unsigned int max_l = voxel.param[1];
const unsigned int R = ((max_l+1)*(max_l+2)/2);
std::vector<std::pair<int,int> > j_map(R);
for (int k = 0; k <= max_l; k += 2)
for (int m = -k; m <= k; ++m)
j_map[getJ(m,k)] = std::make_pair(m,k);
std::vector<float> Bt(R*voxel.bvectors.size());
for (unsigned int j = 0,index = 0; j < R; ++j)
for (unsigned int n = 0; n < voxel.bvectors.size(); ++n,++index)
{
float atan2_xy = std::atan2(voxel.bvectors[n][1],voxel.bvectors[n][0]);
if (atan2_xy < 0.0)
atan2_xy += 2.0*M_PI;
Bt[index] = Yj(j_map[j].second,j_map[j].first,std::acos(voxel.bvectors[n][2]),atan2_xy);
}
std::vector<float> UP(half_odf_size*R);
{
std::vector<float> U(half_odf_size*R);
for (unsigned int n = 0,index = 0; n < half_odf_size; ++n)
for (unsigned int j = 0; j < R; ++j,++index)
{
float atan2_xy = std::atan2(voxel.ti.vertices[n][1],voxel.ti.vertices[n][0]);
if (atan2_xy < 0.0)
atan2_xy += 2.0*M_PI;
U[index] = Yj(j_map[j].second,j_map[j].first,std::acos(voxel.ti.vertices[n][2]),atan2_xy);
}
std::vector<float> P(R*R);
for (unsigned int i = 0,index = 0; i < R; ++i,index += R+1)
P[index] = boost::math::legendre_p(j_map[i].second,0.0)*2.0*M_PI;
image::matrix::product(U.begin(),P.begin(),UP.begin(),image::dyndim(half_odf_size,R),image::dyndim(R,R));
}
std::vector<float> iB(Bt.size());
{
std::vector<float> BtB(R*R); // BtB = Bt * trans(Bt);
image::matrix::square(Bt.begin(),BtB.begin(),image::dyndim(R,voxel.bvectors.size()));
for (unsigned int i = 0,index = 0; i < R; ++i,index += R+1)
{
float l = j_map[i].second;
BtB[index] += l*l*(l+1.0)*(l+1.0)*lambda;
}
std::vector<unsigned int> pivot(R);
image::matrix::lu_decomposition(BtB.begin(),pivot.begin(),image::dyndim(R,R));
//iB = inv(BtB)*Bt;
image::matrix::lu_solve(BtB.begin(),pivot.begin(),Bt.begin(),iB.begin(),image::dyndim(R,R),image::dyndim(R,voxel.bvectors.size()));
}
UPiB.resize(half_odf_size*voxel.bvectors.size());
image::matrix::product(UP.begin(),iB.begin(),UPiB.begin(),image::dyndim(half_odf_size,R),image::dyndim(R,voxel.bvectors.size()));
}
