//**************************************************************************************
//**************************************************************************************
//**************************************************************************************
//**************************************************************************************
void IntrinsicFeatureCalculator::GetObjectCentroids(vtkSmartPointer<vtkTable> table, int time)
{
if(!intensityImage || !labelImage)
{
return;
}
//Compute features:
typedef ftk::LabelImageToFeatures< IPixelT, LPixelT, 3 > FeatureCalcType;
FeatureCalcType::Pointer labFilter = FeatureCalcType::New();
if(useRegion)
{
labFilter->SetImageInputs( intensityImage->GetItkPtr<IPixelT>(time,intensityChannel), labelImage->GetItkPtr<LPixelT>(time,labelChannel), regionIndex, regionSize );
}
else
{
labFilter->SetImageInputs( intensityImage->GetItkPtr<IPixelT>(time,intensityChannel), labelImage->GetItkPtr<LPixelT>(time,labelChannel) );
}
labFilter->Update();
//Init the table (headers):
vtkSmartPointer<vtkDoubleArray> column = vtkSmartPointer<vtkDoubleArray>::New();
column->SetName( "centroid_x" );
column->SetNumberOfValues(table->GetNumberOfRows());
table->AddColumn(column);
column = vtkSmartPointer<vtkDoubleArray>::New();
column->SetName( "centroid_y" );
column->SetNumberOfValues(table->GetNumberOfRows());
table->AddColumn(column);
column = vtkSmartPointer<vtkDoubleArray>::New();
column->SetName( "centroid_z" );
column->SetNumberOfValues(table->GetNumberOfRows());
table->AddColumn(column);
for (int i=0; i<(int)table->GetNumberOfRows(); ++i)
{
FeatureCalcType::LabelPixelType id = table->GetValue(i,0).ToInt();
if(useIDs)
if(IDs.find(id) == IDs.end()) continue; //Don't care about this id, so skip it
ftk::IntrinsicFeatures * features = labFilter->GetFeatures(id);
table->SetValueByName( i, "centroid_x", vtkVariant((int)features->Centroid[0]) );
table->SetValueByName( i, "centroid_y", vtkVariant((int)features->Centroid[1]) );
if( labelImage->GetImageInfo()->numZSlices > 2 )
table->SetValueByName( i, "centroid_z", vtkVariant((int)features->Centroid[2]) );
else
table->SetValueByName( i, "centroid_z", vtkVariant(0) );
}
return;
}
MetricLinePlot(MetricBaseSPtr _metric) :
table(vtkSmartPointer<vtkTable>::New()),
arrX(vtkSmartPointer<vtkFloatArray>::New()),
arrM(vtkSmartPointer<vtkFloatArray>::New()),
view(vtkSmartPointer<vtkContextView>::New()),
chart(vtkSmartPointer<vtkChartXY>::New()),
num_gens(0),
metric(_metric)
{
arrX->SetName("Generations");
table->AddColumn(arrX);
arrM->SetName("Metric");
table->AddColumn(arrM);
view->GetRenderer()->SetBackground(1.0, 1.0, 1.0);
view->GetScene()->AddItem(chart);
}
//Update the features in this table whose names match (sets doFeat)
void AssociativeFeatureCalculator::Append(vtkSmartPointer<vtkTable> table)
{
//Compute features:
ftk::NuclearAssociationRules *assoc;
if( inputs_set ){
assoc = new ftk::NuclearAssociationRules("",0,lab_im, inp_im);
assoc->AddAssociation( input_association->GetRuleName(), "", input_association->GetOutDistance(), input_association->GetInDistance(), input_association->IsUseWholeObject(), input_association->IsUseBackgroundSubtraction(), input_association->IsUseMultiLevelThresholding(), input_association->GetNumberOfThresholds(), input_association->GetNumberIncludedInForeground(), input_association->GetAssocType(), input_association->get_path() );
}
else{
assoc = new ftk::NuclearAssociationRules("",0);
assoc->ReadRulesFromXML(inFilename);
}
assoc->PrintSelf();
assoc->Compute();
//Init the table (headers):
for (int i=0; i < assoc->GetNumofAssocRules(); ++i)
{
vtkSmartPointer<vtkDoubleArray> column = vtkSmartPointer<vtkDoubleArray>::New();
column->SetName( (fPrefix+assoc->GetAssociationRules().at(i).GetRuleName()).c_str() );
column->SetNumberOfValues( table->GetNumberOfRows() );
table->AddColumn(column);
}
//Now update the table:
std::vector<unsigned short> labels = assoc->GetLabels();
float** vals = assoc->GetAssocFeaturesList();
//#pragma omp parallel for num_threads(4)
for (int i=0; i<(int)labels.size(); ++i)
{
unsigned short id = labels.at(i);
if(id == 0) continue;
int row = -1;
for(int r=0; r<table->GetNumberOfRows(); ++r)
{
if( table->GetValue(r,0) == id )
{
row = r;
break;
}
}
if(row == -1) continue;
for (int f=0; f<assoc->GetNumofAssocRules(); ++f)
{
table->SetValueByName(row,(fPrefix+assoc->GetAssociationRules().at(f).GetRuleName()).c_str(), vtkVariant(vals[f][i]));
}
}
delete assoc;
}
void SelectiveClustering::CopySelectedIntoTable(std::set<vtkIdType> selectedIDs, vtkSmartPointer<vtkTable> selectedTable)
{
/*!
* Populate a table containing selected objects
*/
//Add Header Columns
for(vtkIdType NumberOfColumns = 0; NumberOfColumns < this->ObjectTable->GetNumberOfColumns(); NumberOfColumns++ )
{
vtkSmartPointer<vtkVariantArray> col = vtkSmartPointer<vtkVariantArray>::New();
col->SetName(this->ObjectTable->GetColumnName(NumberOfColumns));
selectedTable->AddColumn(col);
}
//
std::set< vtkIdType >::iterator selectionIter = selectedIDs.begin();
for (; selectionIter != selectedIDs.end(); selectionIter++)
{
vtkIdType curSelection = *selectionIter;
this->TableIDIter = this->ObjectTableIDMap.find(curSelection);
if (this->TableIDIter != this->ObjectTableIDMap.end())
{
vtkVariantArray * RowCopy = this->ObjectTable->GetRow((*this->TableIDIter).second);
selectedTable->InsertNextRow(RowCopy);
}
}
////Code to compare timing map vs search
//vtkIdType NumRows = this->ObjectTable->GetNumberOfRows();
//for (vtkIdType row = 0; row <= this->NumberOfObjects; row++)
//{
// vtkIdType rowObjId = this->ObjectTable->GetValue(row, 0).ToTypeInt64();
// //std::cout << "Searching for obj: " << rowObjId << std::endl;
// std::set< vtkIdType >::iterator FoundAt = selectedIDs.find(rowObjId);
// if (FoundAt != selectedIDs.end())
// {
// //std::cout << "found obj: " << rowObjId << std::endl;
// vtkVariantArray * RowCopy = this->ObjectTable->GetRow(row);
// selectedTable->InsertNextRow(RowCopy);
// }
//}
}
void IntrinsicFeatureCalculator::GetDistanceToSurfaceMeasures(vtkSmartPointer<vtkTable> table, std::vector< ftk::Object::Point > surfacePoints)
{
typedef itk::Image< IPixelT, 3 > InputImageType;
typedef itk::Image< LPixelT, 3 > OutputImageType;
typedef itk::DanielssonDistanceMapImageFilter< OutputImageType, OutputImageType > DanielssonFilterType;
typedef itk::RescaleIntensityImageFilter< OutputImageType, OutputImageType > RescalerType;
typedef itk::ImageFileReader< InputImageType > ReaderType;
typedef itk::ImageFileWriter< InputImageType > InputWriterType;
typedef itk::ImageFileWriter< OutputImageType > WriterType;
typedef itk::LineIterator< OutputImageType > LineIteratorType;
vtkSmartPointer<vtkDoubleArray> column = vtkSmartPointer<vtkDoubleArray>::New();
column->SetName( "Dist_To_Surface" );
column->SetNumberOfValues( table->GetNumberOfRows() );
table->AddColumn(column);
OutputImageType::Pointer im;
im = OutputImageType::New();
OutputImageType::PointType origin;
origin[0] = 0;
origin[1] = 0;
origin[2] = 0;
im->SetOrigin( origin );
OutputImageType::IndexType start;
start[0] = 0; // first index on X
start[1] = 0; // first index on Y
start[2] = 0; // first index on Z
OutputImageType::Pointer temp_image = labelImage->GetItkPtr< LPixelT >(0,0);
itk::Size<3> im_size = temp_image->GetBufferedRegion().GetSize();
im_size[2] = 1;
InputImageType::RegionType region;
region.SetSize( im_size );
region.SetIndex( start );
im->SetRegions( region );
im->Allocate();
im->FillBuffer(0);
im->Update();
//copy the input image into the ITK image
for(int p = 1; p < (int)surfacePoints.size(); ++p)
{
itk::Index<3> indx,indy;
indx[0] = surfacePoints[p-1].x;
indx[1] = surfacePoints[p-1].y;
indx[2] = 0;
indy[0] = surfacePoints[p].x;
indy[1] = surfacePoints[p].y;
indy[2] = 0;
LineIteratorType it( im, indx, indy );
//it.GoToBegin();
//while(!it.IsAtEnd())
for(it.GoToBegin(); !it.IsAtEnd(); ++it)
{
it.Set(255);
}
}
DanielssonFilterType::Pointer danielssonFilter = DanielssonFilterType::New();
WriterType::Pointer writer = WriterType::New();
danielssonFilter->SetInput( im );
writer->SetFileName( "DistanceMap.tif" );
danielssonFilter->InputIsBinaryOn();
danielssonFilter->Update();
OutputImageType::Pointer distMap = danielssonFilter->GetOutput();
writer->SetInput( distMap );
writer->Update();
for(int row=0; row<(int)table->GetNumberOfRows(); ++row)
{
OutputImageType::IndexType indx;
indx[0] = table->GetValue(row, 1).ToInt();
indx[1] = table->GetValue(row, 2).ToInt();
indx[2] = 0;
int dist = distMap->GetPixel(indx);
table->SetValueByName(row, "Dist_To_Surface", vtkVariant(dist));
}
}
//Update the features in this table whose names match (sets doFeat)
//Will creat new rows if necessary:
void IntrinsicFeatureCalculator::Append(vtkSmartPointer<vtkTable> table)
{
if(!intensityImage || !labelImage)
return;
//Compute features:
typedef ftk::LabelImageToFeatures< IPixelT, LPixelT, 3 > FeatureCalcType;
FeatureCalcType::Pointer labFilter = FeatureCalcType::New();
if(useRegion)
{
labFilter->SetImageInputs( intensityImage->GetItkPtr<IPixelT>(0,intensityChannel), labelImage->GetItkPtr<LPixelT>(0,labelChannel), regionIndex, regionSize, cyto_image );
}
else
{
labFilter->SetImageInputs( intensityImage->GetItkPtr<IPixelT>(0,intensityChannel), labelImage->GetItkPtr<LPixelT>(0,labelChannel), cyto_image );
}
labFilter->SetLevel( needLevel() );
if( needHistogram() )
labFilter->ComputeHistogramOn();
if( needTextures() )
labFilter->ComputeTexturesOn();
labFilter->Update();
//Add new columns to the table (headers):
for (int i=0; i < IntrinsicFeatures::N; ++i)
{
if(doFeat[i])
{
vtkSmartPointer<vtkDoubleArray> column = vtkSmartPointer<vtkDoubleArray>::New();
column->SetName( (fPrefix+IntrinsicFeatures::Info[i].name).c_str() );
column->SetNumberOfValues( table->GetNumberOfRows() );
table->AddColumn(column);
}
}
//Now update the table:
std::vector< FeatureCalcType::LabelPixelType > labels = labFilter->GetLabels();
for (int i=0; i<(int)labels.size(); ++i)
{
FeatureCalcType::LabelPixelType id = labels.at(i);
if(id == 0) continue;
if(useIDs)
if(IDs.find(id) == IDs.end()) continue; //Don't care about this id, so skip it
int row = -1;
for(int r=0; r<table->GetNumberOfRows(); ++r)
{
if( table->GetValue(r,0) == id )
{
row = r;
break;
}
}
ftk::IntrinsicFeatures * features = labFilter->GetFeatures(id);
//Must Create a new row:
if(row == -1)
{
vtkSmartPointer<vtkVariantArray> nrow = vtkSmartPointer<vtkVariantArray>::New();
for( unsigned ii=0; ii<table->GetNumberOfColumns(); ++ii )
nrow->InsertNextValue( vtkVariant(0.0) );
table->InsertNextRow(nrow);
row = table->GetNumberOfRows() - 1;
table->SetValue(row, 0, vtkVariant(id));
}
for (int f=0; f<IntrinsicFeatures::N; ++f)
{
if(doFeat[f])
table->SetValueByName(row,(fPrefix+IntrinsicFeatures::Info[f].name).c_str(), vtkVariant(features->ScalarFeatures[f]));
}
}
}