void DialogTransformVolume::OnActiveLayerChanged()
{
if ( isVisible() )
{
UpdateUI();
}
LayerMRI* layer = (LayerMRI* )MainWindow::GetMainWindow()->GetActiveLayer( "MRI" );
if (!layer)
return;
connect(layer->GetProperty(), SIGNAL(ColorMapChanged()), this, SLOT(OnActiveLayerChanged()), Qt::UniqueConnection);
LayerLandmarks* landmarks = (LayerLandmarks*)MainWindow::GetMainWindow()->GetSupplementLayer( "Landmarks" );
landmarks->SetMRIRef(layer);
if (layer->GetProperty()->GetColorMap() == LayerPropertyMRI::LUT)
ui->radioButtonNearestNeighbor->setChecked(true);
else
ui->radioButtonCubic->setChecked(true);
OnSampleMethodChanged();
}
void DialogTransformVolume::OnSampleMethodChanged()
{
LayerMRI* layer = (LayerMRI* )MainWindow::GetMainWindow()->GetActiveLayer( "MRI" );
if (layer)
{
int nMethod = SAMPLE_NEAREST;
if (ui->radioButtonTrilinear->isChecked())
nMethod = SAMPLE_TRILINEAR;
else if (ui->radioButtonCubic->isChecked())
nMethod = SAMPLE_CUBIC_BSPLINE;
layer->GetProperty()->SetResliceInterpolation(nMethod);
}
}
void LayerVolumeBase::SaveBufferItem( UndoRedoBufferItem& item, int nPlane, int nSlice, const char* mask )
{
item.plane = nPlane;
item.slice = nSlice;
if ( nPlane >= 0 )
{
int nDim[3], nStart[3] = { 0, 0, 0 };
m_imageData->GetDimensions( nDim );
nDim[nPlane] = 1;
nStart[nPlane] = nSlice;
int nSize = nDim[0]*nDim[1]*nDim[2]*m_imageData->GetScalarSize();
item.data = new char[nSize];
memset( item.data, 0, nSize );
int n = 0;
for ( int i = nStart[0]; i < nStart[0] + nDim[0]; i++ )
{
for ( int j = nStart[1]; j < nStart[1] + nDim[1]; j++ )
{
for ( int k = nStart[2]; k < nStart[2] + nDim[2]; k++ )
{
if ( !mask || mask[n] > 0 )
{
memcpy( item.data + ( (k-nStart[2])*nDim[1]*nDim[0] + (j-nStart[1])*nDim[0] + (i-nStart[0]) ) * m_imageData->GetScalarSize(),
m_imageData->GetScalarPointer( i, j, k ),
m_imageData->GetScalarSize() );
}
n++;
}
}
}
}
else // save whole volume in cache file
{
int nDim[3];
m_imageData->GetDimensions( nDim );
int nSize = nDim[0]*nDim[1]*nDim[2]*m_imageData->GetScalarSize();
QFile file(this->GenerateCacheFileName());
if (!file.open(QIODevice::WriteOnly))
{
return;
}
file.write((char*)m_imageData->GetScalarPointer() + nSize*m_nActiveFrame, nSize);
file.close();
item.cache_filename = file.fileName();
if (this->IsTypeOf("MRI"))
{
LayerMRI* mri = qobject_cast<LayerMRI*>(this);
item.mri_settings = mri->GetProperty()->GetSettings();
}
}
}
void LayerVolumeBase::LoadBufferItem( UndoRedoBufferItem& item, bool bIgnoreZeros )
{
if (item.plane >= 0)
{
int nDim[3], nStart[3] = { 0, 0, 0 };
m_imageData->GetDimensions( nDim );
nDim[item.plane] = 1;
nStart[item.plane] = item.slice;
for ( int i = nStart[0]; i < nStart[0] + nDim[0]; i++ )
{
for ( int j = nStart[1]; j < nStart[1] + nDim[1]; j++ )
{
for ( int k = nStart[2]; k < nStart[2] + nDim[2]; k++ )
{
double dValue = m_imageData->GetScalarComponentAsDouble( i, j, k, 0 );
memcpy( m_imageData->GetScalarPointer( i, j, k ),
item.data + ( (k-nStart[2])*nDim[1]*nDim[0] + (j-nStart[1])*nDim[0] + (i-nStart[0]) ) * m_imageData->GetScalarSize(),
m_imageData->GetScalarSize() );
if ( bIgnoreZeros )
{
if ( m_imageData->GetScalarComponentAsDouble( i, j, k, 0 ) == 0 )
{
m_imageData->SetScalarComponentFromDouble( i, j, k, 0, dValue );
}
}
}
}
}
}
else if (!item.cache_filename.isEmpty())
{
QFile file(item.cache_filename);
if (!file.open(QIODevice::ReadOnly))
{
return;
}
int nDim[3];
m_imageData->GetDimensions( nDim );
int nSize = nDim[0]*nDim[1]*nDim[2]*m_imageData->GetScalarSize();
char* p = (char*)m_imageData->GetScalarPointer() + nSize*m_nActiveFrame;
file.read(p, nSize);
file.close();
if (this->IsTypeOf("MRI"))
{
LayerMRI* mri = qobject_cast<LayerMRI*>(this);
mri->GetProperty()->RestoreSettings(item.mri_settings);
}
m_imageData->Modified();
}
}
void LayerFCD::MakeAllLayers()
{
if (true)
{
LayerMRI* mri = m_mri_norm;
if (m_layerSource)
{
mri->SetRefVolume(m_layerSource->GetSourceVolume());
}
mri->SetName(GetName() + "_norm");
mri->SetFileName(m_fcd->mri_norm->fname);
if ( mri->CreateFromMRIData((void*)m_fcd->mri_norm) )
{
if (!m_layerSource)
{
m_layerSource = mri;
InitializeData();
}
}
else
{
cerr << "Failed to create norm layer" << endl;
delete mri;
m_mri_norm = NULL;
}
}
if (m_fcd->mri_flair)
{
LayerMRI* mri = m_mri_flair;
if (m_layerSource)
{
mri->SetRefVolume(m_layerSource->GetSourceVolume());
}
mri->SetName(GetName() + "_flair");
mri->SetFileName(m_fcd->mri_flair->fname);
if ( !mri->CreateFromMRIData((void*)m_fcd->mri_flair) )
{
delete m_mri_flair;
m_mri_flair = NULL;
}
}
else
{
delete m_mri_flair;
m_mri_flair = NULL;
}
if (m_fcd->mri_t2)
{
LayerMRI* mri = m_mri_t2;
if (m_layerSource)
{
mri->SetRefVolume(m_layerSource->GetSourceVolume());
}
mri->SetName(GetName() + "_t2");
mri->SetFileName(m_fcd->mri_t2->fname);
if ( !mri->CreateFromMRIData((void*)m_fcd->mri_t2) )
{
delete m_mri_t2;
m_mri_t2 = NULL;
}
}
else
{
delete m_mri_t2;
m_mri_t2 = NULL;
}
if (m_fcd->mri_aseg)
{
LayerMRI* mri = m_mri_aseg;
if (m_layerSource)
{
mri->SetRefVolume(m_layerSource->GetSourceVolume());
}
mri->SetName(GetName() + "_aseg");
mri->SetFileName(m_fcd->mri_aseg->fname);
if ( mri->CreateFromMRIData((void*)m_fcd->mri_aseg) )
{
mri->GetProperty()->SetColorMap(LayerPropertyMRI::LUT);
mri->SetVisible(false);
}
else
{
delete m_mri_aseg;
m_mri_aseg = NULL;
}
}
else
{
delete m_mri_aseg;
m_mri_aseg = NULL;
}
if (m_fcd->mri_thickness_difference)
{
LayerMRI* mri = m_mri_difference;
if (m_layerSource)
{
mri->SetRefVolume(m_layerSource->GetSourceVolume());
}
mri->SetName(GetName() + "_thickness_difference");
// mri->SetFileName(m_fcd->mri_thickness_increase->fname);
if ( mri->CreateFromMRIData((void*)m_fcd->mri_thickness_difference) )
{
mri->GetProperty()->SetColorMap(LayerPropertyMRI::Heat);
}
else
{
delete m_mri_difference;
m_mri_difference = NULL;
}
}
else
{
delete m_mri_difference;
m_mri_difference = NULL;
}
if (m_fcd->mris_lh)
{
LayerSurface* surf = m_surf_lh;
if (m_layerSource)
{
surf->SetRefVolume(m_layerSource);
}
surf->SetName(GetName() + "_lh");
if (!surf->CreateFromMRIS((void*)m_fcd->mris_lh))
{
delete m_surf_lh;
m_surf_lh = NULL;
}
}
else
{
delete m_surf_lh;
m_surf_lh = NULL;
}
if (m_fcd->mris_lh_pial)
{
LayerSurface* surf = m_surf_lh_pial;
if (m_layerSource)
{
surf->SetRefVolume(m_layerSource);
}
surf->SetName(GetName() + "_lh.pial");
if (!surf->CreateFromMRIS((void*)m_fcd->mris_lh_pial))
{
delete m_surf_lh_pial;
m_surf_lh_pial = NULL;
}
else
{
surf->GetProperty()->SetEdgeColor(Qt::green);
}
}
else
{
delete m_surf_lh_pial;
m_surf_lh_pial = NULL;
}
if (m_fcd->mris_lh_sphere_d1)
{
LayerSurface* surf = m_surf_lh_sphere_d1;
if (m_layerSource)
{
surf->SetRefVolume(m_layerSource);
}
surf->SetName(GetName() + "_lh.sphere.d1");
if (!surf->CreateFromMRIS((void*)m_fcd->mris_lh_sphere_d1))
{
delete m_surf_lh_sphere_d1;
m_surf_lh_sphere_d1 = NULL;
}
else
{
surf->GetProperty()->SetEdgeColor(Qt::red);
surf->SetVisible(false);
}
}
else
{
delete m_surf_lh_sphere_d1;
m_surf_lh_sphere_d1 = NULL;
}
if (m_fcd->mris_rh)
{
LayerSurface* surf = m_surf_rh;
if (m_layerSource)
{
surf->SetRefVolume(m_layerSource);
}
surf->SetName(GetName() + "_rh");
if (!surf->CreateFromMRIS((void*)m_fcd->mris_rh))
{
delete m_surf_rh;
m_surf_rh = NULL;
}
}
else
{
delete m_surf_rh;
m_surf_rh = NULL;
}
if (m_fcd->mris_rh_pial)
{
LayerSurface* surf = m_surf_rh_pial;
if (m_layerSource)
{
surf->SetRefVolume(m_layerSource);
}
surf->SetName(GetName() + "_rh.pial");
if (!surf->CreateFromMRIS((void*)m_fcd->mris_rh_pial))
{
delete m_surf_rh_pial;
m_surf_rh_pial = NULL;
}
else
{
surf->GetProperty()->SetEdgeColor(Qt::green);
}
}
else
{
delete m_surf_rh_pial;
m_surf_rh_pial = NULL;
}
if (m_fcd->mris_rh_sphere_d1)
{
LayerSurface* surf = m_surf_rh_sphere_d1;
if (m_layerSource)
{
surf->SetRefVolume(m_layerSource);
}
surf->SetName(GetName() + "_rh.sphere.d1");
if (!surf->CreateFromMRIS((void*)m_fcd->mris_rh_sphere_d1))
{
delete m_surf_rh_sphere_d1;
m_surf_rh_sphere_d1 = NULL;
}
else
{
surf->GetProperty()->SetEdgeColor(Qt::red);
surf->SetVisible(false);
}
}
else
{
delete m_surf_rh_sphere_d1;
m_surf_rh_sphere_d1 = NULL;
}
}
void InfoTreeWidget::UpdateAll()
{
this->clear();
m_editor->hide();
LayerCollection* lc_mri = MainWindow::GetMainWindow()->GetLayerCollection( "MRI" );
LayerCollection* lc_surf = MainWindow::GetMainWindow()->GetLayerCollection( "Surface" );
if ( lc_mri->IsEmpty() && lc_surf->IsEmpty())
{
return;
}
QTreeWidgetItem* item = new QTreeWidgetItem(this);
item->setText(0, "RAS");
double ras[3] = {m_dRAS[0], m_dRAS[1], m_dRAS[2]};
if (!lc_mri->IsEmpty())
{
qobject_cast<LayerMRI*>(lc_mri->GetLayer(0))->RemapPositionToRealRAS(m_dRAS, ras);
}
QVariantMap map;
item->setText(1, QString("%1, %2, %3")
.arg(ras[0], 0, 'f', 2)
.arg(ras[1], 0, 'f', 2)
.arg(ras[2], 0, 'f', 2));
map["Type"] = "RAS";
map["EditableText"] = item->text(1);
item->setData(1, Qt::UserRole, map);
for (int i = 0; i < lc_mri->GetNumberOfLayers(); i++)
{
LayerMRI* layer = (LayerMRI*)lc_mri->GetLayer(i);
int nIndex[3];
if ( layer->GetProperty()->GetShowInfo() )
{
QTreeWidgetItem* item = new QTreeWidgetItem(this);
item->setText(0, layer->GetName());
layer->RASToOriginalIndex( ras, nIndex );
double dvalue = layer->GetVoxelValue( m_dRAS );
QString editable = QString("%1, %2, %3").arg(nIndex[0]).arg(nIndex[1]).arg(nIndex[2]);
QString strg = QString("%1 \t[%2]").arg(dvalue).arg(editable);
QString labelStrg;
if (layer->IsTypeOf("PLabel"))
{
labelStrg = ((LayerPLabel*)layer)->GetLabelName(m_dRAS);
}
else
{
labelStrg = layer->GetLabelName( dvalue );
}
if (!labelStrg.isEmpty())
{
strg += " " + labelStrg;
}
item->setText(1, strg);
map.clear();
map["Type"] = "MRI";
map["EditableText"] = editable;
map["Object"] = QVariant::fromValue((QObject*)layer);
item->setData(1, Qt::UserRole, map);
}
}
for (int i = 0; i < lc_surf->GetNumberOfLayers(); i++)
{
LayerSurface* surf = (LayerSurface*)lc_surf->GetLayer(i);
if ( surf->GetProperty()->GetShowInfo() )
{
QTreeWidgetItem* item = new QTreeWidgetItem(this);
item->setText(0, surf->GetName());
double sf_pos[3];
surf->GetSurfaceRASAtTarget( m_dRAS, sf_pos );
QString editable = QString("%1, %2, %3")
.arg(sf_pos[0], 0, 'f', 2)
.arg(sf_pos[1], 0, 'f', 2)
.arg(sf_pos[2], 0, 'f', 2);
item->setText(1, QString("SurfaceRAS\t[%1]").arg(editable));
map.clear();
map["Type"] = "SurfaceRAS";
map["EditableText"] = editable;
map["Object"] = QVariant::fromValue((QObject*)surf);
item->setData(1, Qt::UserRole, map);
int nVertex = surf->GetVertexIndexAtTarget( m_dRAS, NULL );
if ( nVertex >= 0 )
{
surf->GetSurfaceRASAtVertex( nVertex, sf_pos );
QTreeWidgetItem* item = new QTreeWidgetItem(this);
item->setText(1, QString("Vertex \t%1 [%2, %3, %4]")
.arg(nVertex)
.arg(sf_pos[0], 0, 'f', 2)
.arg(sf_pos[1], 0, 'f', 2)
.arg(sf_pos[2], 0, 'f', 2));
map.clear();
map["Type"] = "SurfaceVertex";
map["EditableText"] = QString::number(nVertex);
map["Object"] = QVariant::fromValue((QObject*)surf);
item->setData(1, Qt::UserRole, map);
double vec[3];
surf->GetNormalAtVertex( nVertex, vec );
item = new QTreeWidgetItem(this);
item->setText(1, QString("Normal \t[%1, %2, %3]")
.arg(vec[0], 0, 'f', 2)
.arg(vec[1], 0, 'f', 2)
.arg(vec[2], 0, 'f', 2));
if ( surf->GetActiveVector() >= 0 )
{
surf->GetVectorAtVertex( nVertex, vec );
item = new QTreeWidgetItem(this);
item->setText(1, QString("Vector \t[%1, %2, %3]")
.arg(vec[0], 0, 'f', 2)
.arg(vec[1], 0, 'f', 2)
.arg(vec[2], 0, 'f', 2));
}
if ( surf->HasCurvature() )
{
item = new QTreeWidgetItem(this);
item->setText(1, QString("Curvature \t%1").arg(surf->GetCurvatureValue(nVertex)));
}
int nOverlays = surf->GetNumberOfOverlays();
for ( int i = 0; i < nOverlays; i++ )
{
SurfaceOverlay* overlay = surf->GetOverlay( i );
item = new QTreeWidgetItem(this);
item->setText(1, QString("%1 \t%2").arg(overlay->GetName()).arg(overlay->GetDataAtVertex( nVertex )));
}
int nAnnotations = surf->GetNumberOfAnnotations();
for ( int i = 0; i < nAnnotations; i++ )
{
SurfaceAnnotation* annot = surf->GetAnnotation( i );
item = new QTreeWidgetItem(this);
item->setText(1, QString("%1 \t%2").arg(annot->GetName()).arg(annot->GetAnnotationNameAtVertex( nVertex )));
}
}
}
}
}
bool Interactor2D::ProcessMouseMoveEvent( QMouseEvent* event, RenderView* renderview )
{
RenderView2D* view = ( RenderView2D* )renderview;
MainWindow* mainwnd = MainWindow::GetMainWindow();
if ( mainwnd->IsEmpty() )
{
return Interactor::ProcessMouseMoveEvent( event, renderview );
}
int posX = event->x();
int posY = event->y();
if ( m_bChangeSlice )
{
double* voxelSize = mainwnd->GetLayerCollection( "MRI" )->GetWorldVoxelSize();
int nPlane = view->GetViewPlane();
double dPixelPer = -0.25;
double dPosDiff = ( ( (int)( dPixelPer * ( posY - m_nDownPosY ) ) ) / dPixelPer -
( (int)( dPixelPer * ( m_nMousePosY - m_nDownPosY ) ) ) / dPixelPer )
* dPixelPer * voxelSize[nPlane];
if ( mainwnd->OffsetSlicePosition( nPlane, dPosDiff ) )
{
m_nMousePosX = posX;
m_nMousePosY = posY;
}
}
else if ( m_bMovingCursor )
{
view->UpdateCursorRASPosition( posX, posY );
view->RequestRedraw();
}
else if ( m_bWindowLevel )
{
QList<Layer*> layers = mainwnd->GetLayerCollection( "MRI" )->GetLayers();
LayerMRI* layer = (LayerMRI*)mainwnd->GetActiveLayer("MRI");
if (layer && (!layer->IsVisible() || layer->GetProperty()->GetColorMap() == LayerPropertyMRI::LUT))
{
layer = NULL;
}
if (layer == NULL)
{
for ( int i = 0; i < layers.size(); i++ )
{
layer = ( LayerMRI*)layers[i];
if ( layer->IsVisible() && layer->GetProperty()->GetColorMap() != LayerPropertyMRI::LUT )
{
break;
}
else
{
layer = NULL;
}
}
}
if ( layer )
{
double scaleX = 0.002;
double scaleY = 0.002;
double w = ( posX - m_nMousePosX ) * scaleX;
double l = ( posY - m_nMousePosY ) * scaleY;
double scaleOverall = layer->GetProperty()->GetMaxValue() -
layer->GetProperty()->GetMinValue();
w *= scaleOverall;
l *= scaleOverall;
switch ( layer->GetProperty()->GetColorMap() )
{
case LayerPropertyMRI::Grayscale:
w += layer->GetProperty()->GetWindow();
l += layer->GetProperty()->GetLevel();
if ( w < 0 )
{
w = 0;
}
layer->GetProperty()->SetWindowLevel(w, l);
break;
case LayerPropertyMRI::Heat:
w += layer->GetProperty()->GetHeatScaleMaxThreshold() - layer->GetProperty()->GetHeatScaleMinThreshold();
l += (layer->GetProperty()->GetHeatScaleMaxThreshold() + layer->GetProperty()->GetHeatScaleMinThreshold())/2;
if ( w < 0 )
{
w = 0;
}
layer->GetProperty()->SetHeatScale( l-w/2, l, l+w/2 );
break;
default:
w += layer->GetProperty()->GetMaxGenericThreshold() - layer->GetProperty()->GetMinGenericThreshold();
l += (layer->GetProperty()->GetMaxGenericThreshold() + layer->GetProperty()->GetMinGenericThreshold())/2;
if ( w < 0 )
{
w = 0;
}
layer->GetProperty()->SetMinMaxGenericThreshold( l-w/2, l+w/2 );
break;
}
}
m_nMousePosX = posX;
m_nMousePosY = posY;
}
else if ( m_bSelecting )
{
view->UpdateSelection( posX, posY );
view->RequestRedraw();
}
else
{
if ( event->buttons() & Qt::MidButton || event->buttons() & Qt::RightButton )
{
view->UpdateAnnotation();
view->Update2DOverlay();
if ( event->buttons() & Qt::RightButton )
{
view->EmitZooming();
}
}
else
{
view->UpdateMouseRASPosition( posX, posY );
}
return Interactor::ProcessMouseMoveEvent( event, renderview );
}
return false;
}