bool PairRegressionAnalyzer::showDialog() {
fillInputTableData();
StatisticAnalyzeDialog *dialog = new StatisticAnalyzeDialog();
dialog->SetDialogName("Выберите зависимую переменную:");
QHashIterator<QString,QString> iterator(this->getAllParams());
while (iterator.hasNext()) {
iterator.next();
dialog->addAviabledParam(iterator.value(), iterator.key());
}
dialog->exec();
if (dialog->ParametersList->count()==0) {
return false;
}
parametersList = new QList<QString>();
parametersList->append(dialog->ParametersList->at(0));
StatisticAnalyzeDialog *dialog2 = new StatisticAnalyzeDialog();
dialog2->SetDialogName("Выберите независимую переменную:");
QHashIterator<QString,QString> iterator2(this->getAllParams());
while (iterator2.hasNext()) {
iterator2.next();
dialog2->addAviabledParam(iterator2.value(), iterator2.key());
}
dialog2->exec();
if (dialog2->ParametersList->count()==0) {
return false;
}
parametersList->append(*dialog2->ParametersList);
return true;
}
bool KMLReader::characters(const QString &ch)
{
if (is_point&&is_LineString)
{
QStringList list1, list2;
list1 = ch.split(QRegExp("[ ]"), QString::SkipEmptyParts);
QStringListIterator iterator1(list1);
while (iterator1.hasNext())
{
CPoint f;
list2 = iterator1.next().split(QRegExp("[,]"), QString::SkipEmptyParts);
QStringListIterator iterator2(list2);
bool ok;
double y = iterator2.next().toDouble(&ok);
if (!ok||y<-180||y>180) return true;
double x = iterator2.next().toDouble(&ok);
if (!ok||x<-90||x>90) return true;
if (iterator2.hasNext())
{
double z = iterator2.next().toDouble(&ok);
if (!ok) return true;
f.setData(x,y,z);
has_ele=true;
}
else
{
f.setData(x,y);
if (has_ele==true) has_ele=false;
}
points.insert(points.size(),f);
}
}
return true;
}
void setUp()
{
typedef itk::Image<double, 3> ImageType;
typedef itk::VectorImage<double, 3> VectorImageType;
typedef itk::ImageRegionIterator<ImageType> ImageIteratorType;
typedef itk::ImageDuplicator<ImageType> DuplicatorType;
typedef itk::ComposeImageFilter<ImageType> CompositeFilterType;
// generate two images with one component
ImageType::Pointer imageComponent1 = itk::Image<double, 3>::New();
ImageType::IndexType start;
start.Fill(0);
ImageType::SizeType size;
size.Fill(5);
ImageType::RegionType region;
region.SetSize(size);
region.SetIndex(start);
imageComponent1->SetRegions(region);
imageComponent1->Allocate();
DuplicatorType::Pointer duplicator = DuplicatorType::New();
duplicator->SetInputImage(imageComponent1);
duplicator->Update();
ImageType::Pointer imageComponent2 = duplicator->GetOutput();
// give them differing data
ImageIteratorType iterator1(imageComponent1, imageComponent1->GetLargestPossibleRegion());
iterator1.GoToBegin();
int i = 0;
while (!iterator1.IsAtEnd())
{
iterator1.Set((double)i);
++iterator1;
++i;
}
ImageIteratorType iterator2(imageComponent2, imageComponent2->GetLargestPossibleRegion());
iterator2.GoToBegin();
i = 2000;
while (!iterator2.IsAtEnd())
{
iterator2.Set((double)i);
++iterator2;
++i;
}
// copy into single VectorImage
CompositeFilterType::Pointer compositeFilter = CompositeFilterType::New();
compositeFilter->SetInput(0, imageComponent1);
compositeFilter->SetInput(1, imageComponent2);
compositeFilter->Update();
itk::VectorImage<double, 3>::Pointer multiComponentImage = compositeFilter->GetOutput();
// cast images to mitk
mitk::CastToMitkImage(multiComponentImage, m_mitkMultiComponentImage);
mitk::CastToMitkImage(imageComponent1, m_mitkImageComponent1);
mitk::CastToMitkImage(imageComponent2, m_mitkImageComponent2);
}
void CtrlrPanelCanvas::handleRightClickOnCanvas(const MouseEvent &e)
{
const bool em = getOwner().getProperty(Ids::uiPanelEditMode);
if (!em)
{
PopupMenu m = getRightClickComponentMenu(e);
handleComponentPopupMenu(e, m.show());
return;
}
PopupMenu m;
if (em)
{
m = CtrlrComponentTypeManager::getComponentMenu(em);
getEditMenu(m);
}
else
{
m = getRightClickComponentMenu(e);
}
const int ret = m.show();
if (ret >= 4096)
{
handleComponentPopupMenu(e, ret);
}
else if (ret == 1024)
{
getOwner().setProperty (Ids::uiPanelEditMode, !em);
getOwner().editModeChanged();
}
else if (ret < 1024 && ret > 10)
{
PopupMenu::MenuItemIterator iterator((const PopupMenu &)m);
while (iterator.next())
{
if (iterator.getItem().subMenu)
{
PopupMenu::MenuItemIterator iterator2(*iterator.getItem().subMenu);
while (iterator2.next())
{
if (iterator2.getItem().itemID == ret)
{
addNewComponent (iterator2.getItem().text, e.getPosition(), e.eventComponent);
}
}
}
}
}
else if (ret >= 2048 && ret < 4096)
{
handleEditMenu (ret, e);
}
}
void CtrlrPanelCanvas::handleRightClickOnMultiSelection(const MouseEvent &e)
{
PopupMenu m;
PopupMenu componentSubMenu = CtrlrComponentTypeManager::getComponentMenu(true);
getEditMenu(m);
m.addSeparator();
m.addSubMenu ("Send to layer", getLayerMenu());
m.addSeparator();
m.addSubMenu ("Replace with", componentSubMenu, true);
const int ret = m.show();
if (ret >= 2048 && ret < 4096)
{
handleEditMenu (ret, e);
}
else if (ret >= 4096 && ret < 8192)
{
handleLayerMenu (ret, e);
}
else if (ret < 1024 && ret > 10)
{
String replaceWithComponentName;
PopupMenu::MenuItemIterator iterator((const PopupMenu &)componentSubMenu);
while (iterator.next())
{
if (iterator.getItem().subMenu)
{
PopupMenu::MenuItemIterator iterator2(*iterator.getItem().subMenu);
while (iterator2.next())
{
if (iterator2.getItem().itemID == ret)
{
replaceWithComponentName = iterator2.getItem().text;
break;
}
}
}
}
if (!replaceWithComponentName.isEmpty())
{
Array <CtrlrComponent *> items;
if (owner.getSelection())
items = owner.getSelection()->getItemArray ();
for (int i=0; i<items.size(); i++)
{
if (items[i])
{
replaceComponent (items[i]->getOwner(), replaceWithComponentName);
}
}
}
}
}
Dialog::Dialog(const Dialog& dialog)
: mId(dialog.mId),
mCallId(dialog.mCallId),
mLocalTag(dialog.mLocalTag),
mRemoteTag(dialog.mRemoteTag),
mDirection(dialog.mDirection),
mIdentifier(dialog.mIdentifier),
mState(dialog.mState),
mEvent(dialog.mEvent),
mCode(dialog.mCode),
mDuration(dialog.mDuration),
mNewCallId(dialog.mNewCallId),
mNewLocalTag(dialog.mNewLocalTag),
mNewRemoteTag(dialog.mNewRemoteTag),
mReferredBy(dialog.mReferredBy),
mDisplay(dialog.mDisplay),
mLocalIdentity(dialog.mLocalIdentity),
mLocalDisplay(dialog.mLocalDisplay),
mLocalTarget(dialog.mLocalTarget),
mLocalSessionDescription(dialog.mLocalSessionDescription),
mRemoteIdentity(dialog.mRemoteIdentity),
mRemoteDisplay(dialog.mRemoteDisplay),
mRemoteTarget(dialog.mRemoteTarget),
mRemoteSessionDescription(dialog.mRemoteSessionDescription)
{
UtlDListIterator iterator(dialog.mLocalParameters);
NameValuePairInsensitive* pNameValuePair;
while ((pNameValuePair = dynamic_cast<NameValuePairInsensitive*>(iterator())))
{
mLocalParameters.append(new NameValuePairInsensitive(*pNameValuePair));
}
UtlDListIterator iterator2(dialog.mRemoteParameters);
while ((pNameValuePair = dynamic_cast<NameValuePairInsensitive*>(iterator2())))
{
mRemoteParameters.append(new NameValuePairInsensitive(*pNameValuePair));
}
}
bool P_Thing_Move (int tid, AActor *source, int mapspot, bool fog)
{
AActor *target;
if (tid != 0)
{
FActorIterator iterator1(tid);
source = iterator1.Next();
}
FActorIterator iterator2 (mapspot);
target = iterator2.Next ();
if (source != NULL && target != NULL)
{
return P_MoveThing(source, target->Pos(), fog);
}
return false;
}
//
//###########################################################################
// TestOrder
//###########################################################################
//
bool
TreeTestNode::TestOrder()
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
TreeTestPlug *testPlug1, *testPlug2;
int i, size;
size = iterator1.GetSize();
for (i = 1; i < size; i++)
{
testPlug1 = iterator1.GetNth(i-1);
testPlug2 = iterator2.GetNth(i);
Test_Assumption(testPlug1->value < testPlug2->value);
}
return true;
}
int main(){
MyAllocator allocator;
allocator.constructor(1000);
SplayTree<int,int> lol;
lol.constructor(&allocator);
srand(time(NULL));
int n=10000000;
int k=n;
while(k--){
lol.insert(k);
}
int i=0;
SplayTreeIterator<int,int> iterator(&lol);
while(iterator.hasNext()){
SplayNode<int,int>*node=iterator.next();
int v=node->getKey();
i++;
}
lol.freeze();
assert(i==n);
assert(n==lol.size());
SplayTreeIterator<int,int> iterator2(&lol);
i=0;
while(iterator2.hasNext()){
SplayNode<int,int>*node=iterator2.next();
int v=node->getKey();
i++;
}
assert(i==n);
assert(n==lol.size());
test_remove();
test_iterator();
return 0;
}
TEST(map_iteratorTest, equal_operator)
{
IntCharMap map = { {123, 'c'}, {234, 'd'}, {345, 'e'} };
key_map_iterator<IntCharMap> iterator(map.cbegin());
key_map_iterator<IntCharMap> iterator2(map.cbegin());
EXPECT_EQ(iterator, iterator2);
EXPECT_EQ(iterator, map.cbegin());
++iterator;
++iterator2;
++iterator;
++iterator2;
EXPECT_EQ(iterator, iterator2);
++iterator;
++iterator2;
EXPECT_EQ(iterator, iterator2);
EXPECT_EQ(iterator, map.cend());
}
std::vector<float> compute_ec_features( USImageType::Pointer input_image, USImageType::Pointer inp_labeled, int number_of_rois, unsigned short thresh, int surr_dist, int inside_dist ){
std::vector< float > qfied_num;
std::vector< USImageType::PixelType > labelsList;
std::vector< double > quantified_numbers_cell;
typedef itk::ExtractImageFilter< USImageType, UShortImageType > LabelExtractType;
typedef itk::ImageRegionConstIterator< UShortImageType > ConstIteratorType;
typedef itk::ImageRegionIteratorWithIndex< USImageType > IteratorType;
typedef itk::SignedDanielssonDistanceMapImageFilter<FloatImageType, FloatImageType > DTFilter;
typedef itk::ImageRegionIteratorWithIndex< FloatImageType > IteratorTypeFloat;
typedef itk::LabelGeometryImageFilter< USImageType > GeometryFilterType;
typedef GeometryFilterType::LabelIndicesType labelindicestype;
itk::SizeValueType sz_x, sz_y, sz_z;
sz_x = input_image->GetLargestPossibleRegion().GetSize()[0];
sz_y = input_image->GetLargestPossibleRegion().GetSize()[1];
sz_z = input_image->GetLargestPossibleRegion().GetSize()[2];
if( sz_x==1 || sz_y==1 || sz_z==1 ){
LabelExtractType::Pointer deFilter = LabelExtractType::New();
USImageType::RegionType dRegion = inp_labeled->GetLargestPossibleRegion();
dRegion.SetSize(2,0);
deFilter->SetExtractionRegion(dRegion);
deFilter->SetInput( inp_labeled );
deFilter->SetDirectionCollapseToIdentity();
try{
deFilter->Update();
}
catch( itk::ExceptionObject & excep ){
std::cerr << "Exception caught !" << std::endl;
std::cerr << excep << std::endl;
}
//Dialate input first
WholeCellSeg *dialate_filter = new WholeCellSeg;
dialate_filter->set_nuc_img( deFilter->GetOutput() );
dialate_filter->set_radius( surr_dist );
dialate_filter->RunSegmentation();
UShortImageType::Pointer input_lab = dialate_filter->getSegPointer();
USImageType::Pointer input_labeled = USImageType::New();
USImageType::PointType origint;
origint[0] = 0;
origint[1] = 0;
origint[2] = 0;
input_labeled->SetOrigin( origint );
USImageType::IndexType startt;
startt[0] = 0; // first index on X
startt[1] = 0; // first index on Y
startt[2] = 0; // first index on Z
USImageType::SizeType sizet;
sizet[0] = inp_labeled->GetLargestPossibleRegion().GetSize()[0]; // size along X
sizet[1] = inp_labeled->GetLargestPossibleRegion().GetSize()[1]; // size along Y
sizet[2] = inp_labeled->GetLargestPossibleRegion().GetSize()[2]; // size along Z
USImageType::RegionType regiont;
regiont.SetSize( sizet );
regiont.SetIndex( startt );
input_labeled->SetRegions( regiont );
input_labeled->Allocate();
input_labeled->FillBuffer(0);
input_labeled->Update();
ConstIteratorType pix_buf1( input_lab, input_lab->GetRequestedRegion() );
IteratorType iterator2 ( input_labeled, input_labeled->GetRequestedRegion() );
iterator2.GoToBegin();
for ( pix_buf1.GoToBegin(); !pix_buf1.IsAtEnd(); ++pix_buf1 ){
iterator2.Set( pix_buf1.Get() );
++iterator2;
}
std::vector< float > quantified_numbers;
typedef itk::LabelGeometryImageFilter< USImageType > GeometryFilterType;
typedef GeometryFilterType::LabelIndicesType labelindicestype;
GeometryFilterType::Pointer geomfilt1 = GeometryFilterType::New();
geomfilt1->SetInput( input_labeled );
geomfilt1->SetCalculatePixelIndices( true );
geomfilt1->Update();
labelsList = geomfilt1->GetLabels();
bool zp=false;
for( USImageType::PixelType i=0; i < labelsList.size(); ++i ){
if( labelsList[i] == 0 ){ zp=true; continue; }
std::vector<float> quantified_numbers_cell;
for( unsigned j=0; j<number_of_rois; ++j ) quantified_numbers_cell.push_back((float)0.0);
double centroid_x = geomfilt1->GetCentroid(labelsList[i])[0];
double centroid_y = geomfilt1->GetCentroid(labelsList[i])[1];
labelindicestype indices1;
indices1 = geomfilt1->GetPixelIndices(labelsList[i]);
for( labelindicestype::iterator itPixind = indices1.begin(); itPixind!=indices1.end(); ++itPixind ){
IteratorType iterator1 ( input_image, input_image->GetRequestedRegion() );
iterator1.SetIndex( *itPixind );
if( iterator1.Get() < thresh )
continue;
double x = iterator1.GetIndex()[0];
double y = iterator1.GetIndex()[1];
double angle = atan2((centroid_y-y),fabs(centroid_x-x));
if( (centroid_x-x)>0 )
angle += M_PI_2;
else
angle = M_PI+M_PI-(angle+M_PI_2);
angle = ((number_of_rois-1)*angle)/(2*M_PI);
double angle_fraction[1];
unsigned angular_index;
if( modf( angle, angle_fraction ) > 0.5 )
angular_index = ceil( angle );
else
angular_index = floor( angle );
quantified_numbers_cell[angular_index] += iterator1.Get();
}
for( unsigned j=0; j<number_of_rois; ++j ) quantified_numbers.push_back(quantified_numbers_cell[j]);
}
unsigned qnum_sz = zp? (labelsList.size()-1) : (labelsList.size());
for( unsigned i=0; i<qnum_sz; ++i ){
unsigned counter=0;
for( unsigned j=0; j<number_of_rois; ++j ){
if( quantified_numbers[(i*number_of_rois+j)] > (255.0*surr_dist) )
++counter;
}
qfied_num.push_back(counter);
}
}
else{
GeometryFilterType::Pointer geomfilt1 = GeometryFilterType::New();
geomfilt1->SetInput( inp_labeled );
geomfilt1->SetCalculatePixelIndices( true );
geomfilt1->Update();
labelsList = geomfilt1->GetLabels();
std::cout<<std::endl<<"The size is: "<<labelsList.size();
if( labelsList.size() == 1 )
{
qfied_num.clear();
return qfied_num;
}
bool zp=false; USPixelType zero;
//Check if the background is also included
for( USPixelType i=0; i<labelsList.size(); ++i ) if( labelsList[i] == 0 ){ zp=true; zero = i; }
USImageType::SizeType sizee;
sizee[0] = inp_labeled->GetLargestPossibleRegion().GetSize()[0]; // size along X
sizee[1] = inp_labeled->GetLargestPossibleRegion().GetSize()[1]; // size along Y
sizee[2] = inp_labeled->GetLargestPossibleRegion().GetSize()[2]; // size along Z
itk::SizeValueType roi_list_size = zp ?
((itk::SizeValueType)number_of_rois*(labelsList.size()-1)*2) :
((itk::SizeValueType)number_of_rois*labelsList.size()*2);
std::vector<double> quantified_numbers_cell((roi_list_size),0.0
);
std::cout<<"Bounding boxes computed"<<std::endl;
#ifdef _OPENMP
itk::MultiThreader::SetGlobalDefaultNumberOfThreads(1);
#pragma omp parallel for
#if _OPENMP < 200805L
for( int i=0; i<labelsList.size(); ++i )
#else
for( USImageType::PixelType i=0; i<labelsList.size(); ++i )
#endif
#else
for( USImageType::PixelType i=0; i<labelsList.size(); ++i )
#endif
{
itk::SizeValueType ind;
if( zp && (zero==i) ) continue;
if( zp && (i>zero) ) ind = i-1;
else ind = i;
//Get label indices
labelindicestype indices1;
double centroid_x,centroid_y,centroid_z;
GeometryFilterType::BoundingBoxType boundbox;
#pragma omp critical
{
indices1 = geomfilt1->GetPixelIndices(labelsList[i]);
//Get Centroid
centroid_x = geomfilt1->GetCentroid(labelsList[i])[0];
centroid_y = geomfilt1->GetCentroid(labelsList[i])[1];
centroid_z = geomfilt1->GetCentroid(labelsList[i])[2];
//Create an image with bounding box + 2 * outside distance + 2
//and get distance map for the label
boundbox = geomfilt1->GetBoundingBox(labelsList[i]);
}
//Create vnl array 3xN( label indicies )
vnl_matrix<double> B(3,indices1.size());
FloatImageType::Pointer inp_lab = FloatImageType::New();
FloatImageType::PointType origint; origint[0] = 0; origint[1] = 0; origint[2] = 0;
inp_lab->SetOrigin( origint );
FloatImageType::IndexType startt;
startt[0] = 0; // first index on X
startt[1] = 0; // first index on Y
startt[2] = 0; // first index on Z
FloatImageType::SizeType sizet;
sizet[0] = boundbox[1]-boundbox[0]+2*surr_dist+2; // size along X
sizet[1] = boundbox[3]-boundbox[2]+2*surr_dist+2; // size along Y
sizet[2] = boundbox[5]-boundbox[4]+2*surr_dist+2; // size along Z
FloatImageType::RegionType regiont;
regiont.SetSize( sizet );
regiont.SetIndex( startt );
inp_lab->SetRegions( regiont );
inp_lab->Allocate();
inp_lab->FillBuffer(0.0);
inp_lab->Update();
IteratorTypeFloat iterator444 ( inp_lab, inp_lab->GetRequestedRegion() );
//Populate matrix with deviations from the centroid for principal axes and
//at the same time set up distance-transform computation
itk::SizeValueType ind1=0;
for( labelindicestype::iterator itPixind = indices1.begin(); itPixind!=indices1.end(); ++itPixind ){
IteratorType iterator3( input_image, input_image->GetRequestedRegion() );
iterator3.SetIndex( *itPixind );
B(0,(ind1)) = iterator3.GetIndex()[0]-centroid_x;
B(1,(ind1)) = iterator3.GetIndex()[1]-centroid_y;
B(2,(ind1)) = iterator3.GetIndex()[2]-centroid_z;
FloatImageType::IndexType cur_in;
cur_in[0] = iterator3.GetIndex()[0]-boundbox[0]+1+surr_dist;
cur_in[1] = iterator3.GetIndex()[1]-boundbox[2]+1+surr_dist;
cur_in[2] = iterator3.GetIndex()[2]-boundbox[4]+1+surr_dist;
iterator444.SetIndex( cur_in );
iterator444.Set( 255.0 );
++ind1;
}
//Compute distance transform for the current object
DTFilter::Pointer dt_obj= DTFilter::New() ;
dt_obj->SetInput( inp_lab );
dt_obj->SquaredDistanceOff();
dt_obj->InsideIsPositiveOff();
try{
dt_obj->Update() ;
} catch( itk::ExceptionObject & err ){
std::cerr << "Error in Distance Transform: " << err << std::endl;
}
FloatImageType::Pointer dist_im = dt_obj->GetOutput();
//Use KLT to compute pricipal axes
vnl_matrix<double> B_transp((int)indices1.size(),3);
B_transp = B.transpose();
vnl_matrix<double> COV(3,3);
COV = B * B_transp;
double norm = 1.0/(double)indices1.size();
COV = COV * norm;
//Eigen decomposition
vnl_real_eigensystem Eyegun( COV );
vnl_matrix<vcl_complex<double> > EVals = Eyegun.D;
double Eval1 = vnl_real(EVals)(0,0); double Eval2 = vnl_real(EVals)(1,1); double Eval3 = vnl_real(EVals)(2,2);
vnl_double_3x3 EVectMat = Eyegun.Vreal;
double V1[3],V2[3],EP_norm[3];
if( Eval1 >= Eval3 && Eval2 >= Eval3 ){
if( Eval1 >= Eval2 ){
V1[0] = EVectMat(0,0); V1[1] = EVectMat(1,0); V1[2] = EVectMat(2,0);
V2[0] = EVectMat(0,1); V2[1] = EVectMat(1,1); V2[2] = EVectMat(2,1);
} else {
V2[0] = EVectMat(0,0); V2[1] = EVectMat(1,0); V2[2] = EVectMat(2,0);
V1[0] = EVectMat(0,1); V1[1] = EVectMat(1,1); V1[2] = EVectMat(2,1);
}
} else if( Eval1 >= Eval2 && Eval3 >= Eval2 ) {
if( Eval1 >= Eval3 ){
V1[0] = EVectMat(0,0); V1[1] = EVectMat(1,0); V1[2] = EVectMat(2,0);
V2[0] = EVectMat(0,2); V2[1] = EVectMat(1,2); V2[2] = EVectMat(2,2);
} else {
V2[0] = EVectMat(0,0); V2[1] = EVectMat(1,0); V2[2] = EVectMat(2,0);
V1[0] = EVectMat(0,2); V1[1] = EVectMat(1,2); V1[2] = EVectMat(2,2);
}
} else {
if( Eval2 >= Eval3 ){
V1[0] = EVectMat(0,1); V1[1] = EVectMat(1,1); V1[2] = EVectMat(2,1);
V2[0] = EVectMat(0,2); V2[1] = EVectMat(1,2); V2[2] = EVectMat(2,2);
} else {
V2[0] = EVectMat(0,1); V2[1] = EVectMat(1,1); V2[2] = EVectMat(2,1);
V1[0] = EVectMat(0,2); V1[1] = EVectMat(1,2); V1[2] = EVectMat(2,2);
}
}
double n_sum = sqrt( V1[0]*V1[0]+V1[1]*V1[1]+V1[2]*V1[2] );
V1[0] /= n_sum; V1[1] /= n_sum; V1[2] /= n_sum;
n_sum = sqrt( V2[0]*V2[0]+V2[1]*V2[1]+V2[2]*V2[2] );
V2[0] /= n_sum; V2[1] /= n_sum; V2[2] /= n_sum;
//Get the normal to the plane formed by the biggest two EVs
EP_norm[0] = V1[1]*V2[2]-V1[2]*V2[1];
EP_norm[1] = V1[2]*V2[0]-V1[0]*V2[2];
EP_norm[2] = V1[0]*V2[1]-V1[1]*V2[0];
//Reassign V2 so that it is orthogonal to both EP_norm and V1
V2[0] = V1[1]*EP_norm[2]-V1[2]*EP_norm[1];
V2[1] = V1[2]*EP_norm[0]-V1[0]*EP_norm[2];
V2[2] = V1[0]*EP_norm[1]-V1[1]*EP_norm[0];
//Now we have the point normal form; EP_norm is the normal and
//centroid_x, centroid_y, centroid_z is the point
//The equation to the plane is EP_norm[0](x-centroid_x)+EP_norm[1](y-centroid_y)+EP_norm[2](z-centroid_z)=0
double dee = (centroid_x*EP_norm[0]+centroid_y*EP_norm[1]+centroid_z*EP_norm[2])*(-1.00);
//Iterate through and assign values to each region
typedef itk::ImageRegionConstIterator< FloatImageType > ConstIteratorTypeFloat;
ConstIteratorTypeFloat pix_buf2( dist_im, dist_im->GetRequestedRegion() );
IteratorType iterator44( input_image, input_image->GetRequestedRegion() );
for ( pix_buf2.GoToBegin(); !pix_buf2.IsAtEnd(); ++pix_buf2 ){
//Use pixels that are only within the defined radius from the nucleus
double current_distance = pix_buf2.Get();
if( (current_distance <= (double)surr_dist) && (current_distance>=(-1*inside_dist)) ){
USImageType::IndexType cur_in;//,cur_in_cpy;
double n_vec[3];
cur_in[0] = pix_buf2.GetIndex()[0]+boundbox[0]-1-surr_dist;
cur_in[1] = pix_buf2.GetIndex()[1]+boundbox[2]-1-surr_dist;
cur_in[2] = pix_buf2.GetIndex()[2]+boundbox[4]-1-surr_dist;
//cur_in_cpy[0] = cur_in[0]; cur_in_cpy[1] = cur_in[1]; cur_in_cpy[2] = cur_in[2];
if( cur_in[0] < 0 || cur_in[1] < 0 || cur_in[2] < 0 ) continue;
if( cur_in[0] >= sizee[0] || cur_in[1] >= sizee[1] || cur_in[2] >= sizee[2] ) continue;
iterator44.SetIndex( cur_in );
USImageType::PixelType pixel_intensity;
pixel_intensity = iterator44.Get();
if( pixel_intensity < thresh ) continue;
//The projection of the point on the plane formed by the fist two major axes
double xxx, yyy, zzz;
xxx = cur_in[0] - EP_norm[0]*((EP_norm[0]*cur_in[0]+EP_norm[1]*cur_in[1]+EP_norm[2]*cur_in[2]+dee)
/(EP_norm[0]*EP_norm[0]+EP_norm[1]*EP_norm[1]+EP_norm[2]*EP_norm[2]));
yyy = cur_in[1] - EP_norm[1]*((EP_norm[0]*cur_in[0]+EP_norm[1]*cur_in[1]+EP_norm[2]*cur_in[2]+dee)
/(EP_norm[0]*EP_norm[0]+EP_norm[1]*EP_norm[1]+EP_norm[2]*EP_norm[2]));
zzz = cur_in[2] - EP_norm[2]*((EP_norm[0]*cur_in[0]+EP_norm[1]*cur_in[1]+EP_norm[2]*cur_in[2]+dee)
/(EP_norm[0]*EP_norm[0]+EP_norm[1]*EP_norm[1]+EP_norm[2]*EP_norm[2]));
//The vector from the centroid to the projected point
n_vec[0] = centroid_x-xxx;
n_vec[1] = centroid_y-yyy;
n_vec[2] = centroid_z-zzz;
n_sum = sqrt( n_vec[0]*n_vec[0] + n_vec[1]*n_vec[1] + n_vec[2]*n_vec[2] );
n_vec[0] /= n_sum; n_vec[1] /= n_sum; n_vec[2] /= n_sum;
//n_vec is the normalized vect in the direction of the projected point
//V1 is the largest eigenvector
//Get the dot and cross product between the two
double doooot, crooos,fin_est_angle;
doooot = n_vec[0]*V1[0]+n_vec[1]*V1[1]+n_vec[2]*V1[2];
crooos = n_vec[0]*V2[0]+n_vec[1]*V2[1]+n_vec[2]*V2[2];
fin_est_angle = atan2( crooos, doooot );
USPixelType bin_num;
//Compute bin num
if( fin_est_angle<0 )
fin_est_angle += (2*M_PI);
bin_num = floor(fin_est_angle*number_of_rois/(2*M_PI));
//Check which side of the plane the point lies on
double v_norm = (cur_in[0]-centroid_x)*(cur_in[0]-centroid_x)
+(cur_in[1]-centroid_y)*(cur_in[1]-centroid_y)
+(cur_in[2]-centroid_z)*(cur_in[2]-centroid_z);
v_norm = sqrt( v_norm );
double doot = (cur_in[0]-centroid_x)*EP_norm[0]/v_norm + (cur_in[1]-centroid_y)*EP_norm[1]/v_norm + (cur_in[2]-centroid_z)*EP_norm[2]/v_norm;
if( doot<0 )
bin_num += number_of_rois;
quantified_numbers_cell.at((ind*(2*number_of_rois)+bin_num)) += pixel_intensity;
}
}
}
number_of_rois = number_of_rois*2;
if( labelsList.size() == 1 )
{
qfied_num.clear();
return qfied_num;
}
std::vector<double> quantified_numbers_cell_cpy(roi_list_size);
std::copy(quantified_numbers_cell.begin(), quantified_numbers_cell.end(), quantified_numbers_cell_cpy.begin() );
//Run k-means
//Most of the code is adapted from mul/mbl/mbl_k_means.cxx
std::sort(quantified_numbers_cell.begin(), quantified_numbers_cell.end());
bool skipKmeans;
double Positive_thresh;
if( quantified_numbers_cell.at(0) == quantified_numbers_cell.at(quantified_numbers_cell.size()-1) )
skipKmeans = true;
if( !skipKmeans ){
std::cout<<"Starting k-means\n";
std::cout<<"First:"<<quantified_numbers_cell.at(0)<<" Last:"<<quantified_numbers_cell.at(quantified_numbers_cell.size()-1)<<std::endl;
unsigned k = 2;
//Vectors and matrices for k-means
std::vector< USImageType::PixelType > partition( roi_list_size, 0 );
std::vector< double > sums ( k, 0.0 );
std::vector< double > centers( k, 0.0 );
std::vector< USImageType::PixelType > nNearest( k, 0 );
//Use the elements that are evenly spaced to get the intial centers
for( unsigned i=0; i<k; ++i ){
double index = ((double)(i)*roi_list_size)/(k+1);
centers.at(i) = quantified_numbers_cell.at((itk::SizeValueType)index);
bool duplicated;
std::cout<<"Initializing centers\n"<<std::flush;
if(i){
if( centers.at((i-1)) == centers.at(i) ){
duplicated = true;
itk::SizeValueType ind=i+1;
while( centers.at((i-1))==quantified_numbers_cell.at(ind) )
++ind;
centers.at(i) = quantified_numbers_cell.at(ind);
sums.at(i) = quantified_numbers_cell.at(ind);
}
}
if(!duplicated)
sums.at(i) = quantified_numbers_cell.at((i+1)/(k+1));
++nNearest[i];
}
bool changed = true;
std::cout<<"Waiting for kmeans to converge\n"<<std::flush;
while(changed){
changed = false;
for(itk::SizeValueType i=0; i<roi_list_size; ++i){
unsigned bestCentre = 0;
double bestDist = fabs((centers.at(0)-quantified_numbers_cell.at(i)));
for(unsigned j=1; j<k; ++j){
double dist = fabs((centers.at(j)-quantified_numbers_cell.at(i)));
if( dist < bestDist ){
bestDist = dist; bestCentre = j;
}
}
sums[bestCentre] += quantified_numbers_cell.at(i);
++ nNearest[bestCentre];
if( bestCentre != partition.at(i) ){
changed = true;
partition.at(i) = bestCentre;
}
}
for( unsigned j=0; j<k; ++j) centers.at(j) = sums.at(j)/nNearest.at(j);
for( unsigned j=0; j<k; ++j) sums.at(j) = 0;
for( unsigned j=0; j<k; ++j) nNearest.at(j) = 0;
}
for( unsigned i=0; i<k; ++i )
std::cout<<"Center "<<i<<" "<<centers.at(i)<<"\n";
Positive_thresh = ((centers.at(0)+centers.at(1))/2) < (255.0*thresh)?
((centers.at(0)+centers.at(1))/2) : (255.0*thresh); //Arbitrary upper thresh
}
else
Positive_thresh = 255.0*thresh;
std::cout<<"Positive_thresh "<<Positive_thresh<<"\n";
std::cout<<"Done k-means\n";
itk::SizeValueType ind = 0;
for( USPixelType i=0; i<labelsList.size(); ++i ){
if( zp && (zero==i) ) continue;
int num_positive_rois = 0;
for( unsigned j=0; j<number_of_rois; ++j ){
itk::SizeValueType index_of_roi = ind*number_of_rois+j;
if( quantified_numbers_cell_cpy.at(index_of_roi)>Positive_thresh )
++num_positive_rois;
}
qfied_num.push_back(num_positive_rois);
++ind;
}
}
std::cout<<"Done surroundedness\n"<<std::flush;
return qfied_num;
}
inline iterator2 find () {
return iterator2 (*this);
}
/* use this function to compute one associative measurement */
float NuclearAssociationRules::ComputeOneAssocMeasurement(itk::SmartPointer<TargImageType> trgIm, int ruleID, int objID)
{
//fisrt, get the bounding box around the object
//The bounding box is defined by the area around the object such that the object+outerdistance are included
int imBounds[6] = {0,x_Size,0,y_Size,0,z_Size};
LabelGeometryType::BoundingBoxType bbox = labGeometryFilter->GetBoundingBox(objID);
//make sure the object exists
int valid = 0;
for(int dim=0; dim < imDim*2; ++dim)
{
if(bbox[dim] > 0)
valid = 1;
}
if(valid == 0)
return -1;
std::vector< int > retBbox(0);
int dist, val;
dist = assocRulesList[ruleID].GetOutDistance();
for(int dim=0; dim < imDim*2; ++dim)
{
if(dim%2 == 0) //even
{
val = int(bbox[dim])-dist-1;
if(val<imBounds[dim])
val=imBounds[dim];
}
else //odd
{
val = int(bbox[dim])+dist+1;
if(val>=imBounds[dim])
val=imBounds[dim]-1;
}
retBbox.push_back( val );
}
//the bounding box defines the region of interest we need (from both segmentation and target images)
//so, use it to get sub images
DistImageType::Pointer subSegImg = DistImageType::New();
LabImageType::IndexType start;
start[0] = 0; // first index on X
start[1] = 0; // first index on Y
start[2] = 0; // first index on Z
LabImageType::SizeType size;
size[0] = retBbox[1]-retBbox[0]+1; // size along X
size[1] = retBbox[3]-retBbox[2]+1; // size along Y
if(imDim == 3)
size[2] = retBbox[5]-retBbox[4]+1; // size along Z
else
size[2] = 1;
LabImageType::RegionType region;
region.SetSize( size );
region.SetIndex( start );
subSegImg->SetRegions( region );
subSegImg->Allocate();
subSegImg->FillBuffer(0);
subSegImg->Update();
LabImageType::IndexType start2;
start2[0] = retBbox[0]; // first index on X
start2[1] = retBbox[2]; // first index on Y
if(imDim == 3)
start2[2] = retBbox[4]; // first index on Z
else
start2[2] = 0;
LabImageType::RegionType region2;
region2.SetSize( size );
region2.SetIndex( start2 );
labImage->SetRequestedRegion(region2);
trgIm->SetRequestedRegion(region2);
typedef itk::ImageRegionIteratorWithIndex< LabImageType > IteratorType;
IteratorType iterator1(labImage, labImage->GetRequestedRegion());
typedef itk::ImageRegionIteratorWithIndex< DistImageType > IteratorType2;
IteratorType2 iterator2(subSegImg, subSegImg->GetRequestedRegion());
//in the sub-segmentation image, we need to mask out any pixel from another object
int counter = 0;
while ( ! iterator1.IsAtEnd())
{
int V = iterator1.Get();
if(V == objID)
{
iterator2.Set(255.0);
counter++; //just for debuging purposes,, will be removed
}
else
iterator2.Set(0.0);
++iterator1;
++iterator2;
}
//Let's try this (for debugging): save the binary mask
/* typedef itk::Image< unsigned short, 3 > OutputImageType;
typedef itk::CastImageFilter< DistImageType, OutputImageType > CastType;
CastType::Pointer cast = CastType::New();
cast->SetInput( subSegImg );
cast->Update();
typedef itk::ImageFileWriter< OutputImageType > WriterType;
WriterType::Pointer writer = WriterType::New( );
writer->SetInput( cast->GetOutput() );
writer->SetFileName( "c:/bin_mask.tif" );
writer->Update(); */
//Compute the distance transform in the sub-segmentation image region
DTFilter::Pointer dt_obj= DTFilter::New() ;
dt_obj->SetInput(subSegImg) ;
//dt_obj->SetInsideValue(255.0);
//dt_obj->SetOutsideValue(0.0);
try{
dt_obj->Update() ;
}
catch( itk::ExceptionObject & err ){
std::cout << "Error in Distance Transform: " << err << std::endl;
return 0;
}
//Let's try this (for debugging): save the distance map
////typedef itk::Image< unsigned short, 3 > OutputImageType;
////typedef itk::CastImageFilter< DistImageType, OutputImageType > CastType;
////CastType::Pointer cast = CastType::New();
//cast->SetInput( dt_obj->GetOutput() );
//cast->Update();
////typedef itk::ImageFileWriter< OutputImageType > WriterType;
////WriterType::Pointer writer = WriterType::New( );
//writer->SetInput( cast->GetOutput() );
//writer->SetFileName( "c:/dist_map.tif" );
//writer->Update();
//now, mask out all the pixels (in the sub-seg image) that are not in the region of interest as defined by the association rule and get the intensities of the needed pixels from the target image. The intensities are saved into an std vector
IteratorType2 iterator3(dt_obj->GetOutput(), dt_obj->GetOutput()->GetRequestedRegion());
IteratorType iterator4(trgIm, trgIm->GetRequestedRegion());
std::vector<int> trgInt;
int counter_in = 0;
int counter_at = 0;
int counter_ot = 0;
while ( ! iterator3.IsAtEnd())
{
int V = (int)iterator3.Get();
if(V<0)
counter_in++;
if(V==0)
counter_at++;
if(V>0)
counter_ot++;
//if it is outside with distance less than outDistance away
if(V>0 && V<=assocRulesList[ruleID].GetOutDistance())
trgInt.push_back(iterator4.Get());
//if it is inside and the whole cell is used
else if(V<=0 && assocRulesList[ruleID].IsUseWholeObject())
trgInt.push_back(iterator4.Get());
//if it is inside with distance less than in Distance
else if(V<=0 && abs(V)<=assocRulesList[ruleID].GetInDistance())
trgInt.push_back(iterator4.Get());
++iterator3;
++iterator4;
}
if(!trgInt.size())
return 0;
//Finally, given the list of intensities compute the associative measrement based on the type defined by the association rule
switch(assocRulesList[ruleID].GetAssocType())
{
case ASSOC_MIN:
return FindMin(trgInt);
break;
case ASSOC_MAX:
return FindMax(trgInt);
break;
case ASSOC_TOTAL:
return ComputeTotal(trgInt);
break;
case ASSOC_AVERAGE:
return ComputeAverage(trgInt);
break;
default:
return ComputeAverage(trgInt);
}
//we will never go here, just silencing a compiler warning
return 0.0;
}
bool
SafeChainTestNode::RunTest()
{
SafeChainTestPlug *testPlug1, *testPlug2;
int i, j;
// Time startTicks;
//
//--------------------------------------------------------------------
// Stress tests
//--------------------------------------------------------------------
//
/*
* Create plugs and add to both sockets
*/
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new SafeChainTestPlug(i);
Register_Object( testPlug1 );
chain1.Add(testPlug1);
chain2.Add(testPlug1);
}
/*
* Test_Assumption first and last
*/
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
iterator1.First();
iterator2.First();
testPlug1 = iterator1.GetCurrent();
testPlug2 = iterator2.GetCurrent();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1 == iterator1.GetNth(0) );
Test_Assumption( testPlug1 == iterator2.GetNth(0) );
iterator1.Last();
iterator2.Last();
testPlug1 = iterator1.GetCurrent();
testPlug2 = iterator2.GetCurrent();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1 == iterator1.GetNth(TEST_COUNT - 1) );
Test_Assumption( testPlug1 == iterator2.GetNth(TEST_COUNT - 1) );
}
/*
* Test_Assumption next and prev
*/
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.GetCurrent()) != NULL)
{
testPlug2 = iterator2.GetCurrent();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
iterator1.Next();
iterator2.Next();
i++;
}
Test_Assumption( i == TEST_COUNT );
iterator1.Last();
iterator2.Last();
i = TEST_COUNT - 1;
while ((testPlug1 = iterator1.GetCurrent()) != NULL)
{
testPlug2 = iterator2.GetCurrent();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
iterator1.Previous();
iterator2.Previous();
i--;
}
Test_Assumption( i == -1 );
}
/*
* Test_Assumption read next and read prev
*/
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
{
testPlug2 = iterator2.ReadAndNext();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
i++;
}
Test_Assumption( i == TEST_COUNT );
iterator1.Last();
iterator2.Last();
i = TEST_COUNT - 1;
while ((testPlug1 = iterator1.ReadAndPrevious()) != NULL)
{
testPlug2 = iterator2.ReadAndPrevious();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
i--;
}
Test_Assumption( i == -1 );
}
/*
* Test_Assumption nth
*/
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = iterator1.GetNth(i);
testPlug2 = iterator2.GetNth(i);
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
}
}
/*
* Test_Assumption Remove
*/
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.GetCurrent()) != NULL)
{
Test_Assumption( testPlug1->value == i );
iterator1.Remove();
testPlug2 = iterator2.GetNth(0);
Test_Assumption( testPlug2->value == i );
Test_Assumption( testPlug1 == testPlug2 );
Unregister_Object( testPlug2 );
delete(testPlug2);
i++;
}
Test_Assumption( i == TEST_COUNT );
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
}
/*
* Test_Assumption random deletion
*/
{
/*
* Add plugs to both sockets
*/
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new SafeChainTestPlug(i);
Register_Object( testPlug1 );
chain1.Add(testPlug1);
chain2.Add(testPlug1);
}
}
{
/*
* Perform random deletion
*/
int size, index;
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while((size = iterator1.GetSize()) != 0)
{
index = Random::GetLessThan(size);
testPlug1 = iterator1.GetNth(index);
iterator1.Remove();
testPlug2 = iterator2.GetNth(index);
Test_Assumption( testPlug1 == testPlug2 );
Unregister_Object( testPlug2 );
delete(testPlug2);
i++;
}
Test_Assumption( i == TEST_COUNT );
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
}
/*
* Test_Assumption insertion
*/
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
Test_Assumption(iterator1.GetSize() == 0);
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new SafeChainTestPlug(i);
Register_Object(testPlug1);
if (i == 0)
{
chain1.Add(testPlug1);
}
else
{
iterator1.First();
iterator1.Insert(testPlug1);
}
}
for (i = 0, j = TEST_COUNT-1; i < TEST_COUNT; i++, j--)
{
testPlug1 = iterator1.GetNth(i);
Test_Assumption(testPlug1->value == j);
}
iterator1.DeletePlugs();
}
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
Test_Assumption(iterator1.GetSize() == 0);
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new SafeChainTestPlug(i);
Register_Object(testPlug1);
if (i == 0)
{
chain1.Add(testPlug1);
}
else
{
iterator1.Last();
iterator1.Insert(testPlug1);
}
}
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = iterator1.GetNth(i);
if (i == TEST_COUNT-1)
{
Test_Assumption(testPlug1->value == 0);
}
else
{
Test_Assumption(testPlug1->value == i+1);
}
}
iterator1.DeletePlugs();
}
return true;
}
// Determine if the intersection of three reference lists is empty.
// - this (which we will refer as refList0), refList1 and reflist2.
NABoolean MdamRefList::intersectEmpty(const MdamRefList & refList1,
const MdamRefList & refList2)
{
// For readability purpose, let's refer to this pointer as reflist0.
MdamRefList *refList0 = this;
// Obtain the first disjunct number from each list.
Int32 disjunctNum0 = disjunctNumInitialValue;
Int32 disjunctNum1 = disjunctNumInitialValue;
Int32 disjunctNum2 = disjunctNumInitialValue;
MdamRefListIterator iterator0(refList0);
MdamRefListIterator iterator1(&refList1);
MdamRefListIterator iterator2(&refList2);
NABoolean more0 = iterator0(disjunctNum0);
NABoolean more1 = iterator1(disjunctNum1);
NABoolean more2 = iterator2(disjunctNum2);
// Iterate finding disjunct numbers common to all three lists.
// Stop when one is found or when one of the refLists is exhausted.
while (more0 && more1 && more2)
{
if (disjunctNum0 == disjunctNum1)
{
if (disjunctNum0 == disjunctNum2)
return FALSE; // Found a match in refList0 refList1 and refList2!
// intersection is non-empty.
else if (disjunctNum0 < disjunctNum2)
{
// We already know disjunctNum0=disjunctNum1.
// Advance both refList0 and refList1.
more0 = iterator0(disjunctNum0);
more1 = iterator1(disjunctNum1);
}
else
{
// Must be disjunctNum2<disjunctNum0 and
// disjunctNum2<disjunctNum1
more2 = iterator2(disjunctNum2);
}
}
else if (disjunctNum0 < disjunctNum1)
{
if (disjunctNum0 < disjunctNum2)
{
// Disjunct number from list 0 is less than 1 and 2.
// Advance list 0.
more0 = iterator0(disjunctNum0);
}
else
{
// We know disjunctNum2 <= disjunctNum0 < disjunctNum1
more0 = iterator0(disjunctNum0);
more2 = iterator2(disjunctNum2);
}
}
else // (disjunctNum1 < disjunctNum0)
{
if (disjunctNum1 < disjunctNum2)
{
// Disjunct number from list 1 is less than from 0 and 2.
// Advance list 1.
more1 = iterator1(disjunctNum1);
}
else
{
// We know that disjunctNum2 <= disjunctNum1 < disjunctNum0
more1 = iterator1(disjunctNum1);
more2 = iterator2(disjunctNum2);
}
}
}//While
return TRUE; // Return true because the intersection is empty.
}
bool
SafeChainTestNode::RunProfile()
{
SafeChainTestPlug *testPlug1;
int i;
Time startTicks;
//
//--------------------------------------------------------------------
// Run timing tests
//--------------------------------------------------------------------
//
/*
* Create plugs and add to both sockets
*/
startTicks = gos_GetHiResTime();
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new SafeChainTestPlug(i);
Register_Object( testPlug1 );
chain1.Add(testPlug1);
chain2.Add(testPlug1);
}
SPEW((
GROUP_STUFF_TEST,
"SafeChainTestNode::RunTest Create = %f",
gos_GetHiResTime() - startTicks
));
/*
* Iterate over both sockets
*/
startTicks = gos_GetHiResTime();
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
{
Test_Assumption( testPlug1->value == i );
i++;
}
Test_Assumption( i == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator2.ReadAndNext()) != NULL)
{
Test_Assumption( testPlug1->value == i );
i++;
}
Test_Assumption( i == TEST_COUNT );
}
SPEW((
GROUP_STUFF_TEST,
"SafeChainTestNode::RunTest Iterate = %f",
gos_GetHiResTime() - startTicks
));
/*
* Destroy from chain1, verify with chain2
*/
startTicks = gos_GetHiResTime();
{
SafeChainIteratorOf<SafeChainTestPlug*> iterator1(&chain1);
SafeChainIteratorOf<SafeChainTestPlug*> iterator2(&chain2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
{
Test_Assumption( testPlug1->value == i );
i++;
Unregister_Object( testPlug1 );
delete(testPlug1);
}
Test_Assumption( i == TEST_COUNT );
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
}
SPEW((
GROUP_STUFF_TEST,
"SafeChainTestNode::RunTest Destroy = %f",
gos_GetHiResTime() - startTicks
));
return true;
}
void CtrlrPanelCanvas::handleRightClickOnComponent(const MouseEvent &e)
{
CtrlrComponent *c = findEventComponent(e);
if (c == 0)
return;
if (dynamic_cast<ResizableBorderComponent*>(e.eventComponent) == 0 && getOwner().getSelection())
{
getOwner().getSelection()->selectOnly (c);
}
PopupMenu m;
PopupMenu componentSubMenu = CtrlrComponentTypeManager::getComponentMenu(true);
m.addSectionHeader ("Actions");
m.addItem (512, "Export component");
m.addItem (513, "Lock", true, c->getProperty(Ids::componentIsLocked));
m.addSectionHeader ("Layout");
m.addItem (1024, "Send to back");
m.addItem (1025, "Send to front");
m.addSubMenu ("Send to layer", getLayerMenu());
m.addSeparator();
m.addSubMenu ("Replace with", componentSubMenu, true);
m.addSeparator();
getEditMenu(m);
m.addSeparator();
if (CtrlrComponentTypeManager::isGroupingComponent(c))
{
m.addItem (1026, "Delete with children");
m.addItem (1027, "Copy with children");
}
const int ret = m.show();
if (ret == 512)
{
exportSelectedComponents();
}
else if (ret == 513)
{
c->setProperty (Ids::componentIsLocked, !c->getProperty(Ids::componentIsLocked));
}
if (ret == 1024)
{
c->toBack();
c->setProperty (Ids::componentSentBack, true);
}
else if (ret == 1025)
{
c->toFront(false);
c->setProperty (Ids::componentSentBack, false);
}
else if (ret == 1026)
{
deleteWithChildren (c);
}
else if (ret == 1027)
{
copyWithChildren (c);
}
else if (ret >= 2048 && ret < 4096)
{
handleEditMenu (ret, e);
}
else if (ret >= 4096 && ret < 8192)
{
handleLayerMenu (ret, e);
}
else if (ret < 1024 && ret > 10)
{
PopupMenu::MenuItemIterator iterator((const PopupMenu &)componentSubMenu);
while (iterator.next())
{
if (iterator.getItem().subMenu)
{
PopupMenu::MenuItemIterator iterator2(*iterator.getItem().subMenu);
while (iterator2.next())
{
if (iterator2.getItem().itemID == ret)
{
if (c)
{
replaceComponent (c->getOwner(), iterator2.getItem().text);
return;
}
}
}
}
}
}
}
int runGrAnisDiff(unsigned char* imgIn, int r, int c, int z, int iter, int timeStep, int comductance)
{
//pixel types
typedef unsigned char InputPixelType;
typedef float OutputPixelType;
typedef itk::Image< InputPixelType, 3 > InputImageType;
typedef itk::Image< OutputPixelType, 3 > OutputImageType;
//create an ITK image from the input image
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::SizeType size;
size[0] = c; // size along X
size[1] = r; // size along Y
size[2] = z; // size along Z
OutputImageType::RegionType region;
region.SetSize( size );
region.SetIndex( start );
// double spacing[3];
//spacing[0] = 1; //spacing along x
//spacing[1] = 1; //spacing along y
//spacing[2] = sampl_ratio; //spacing along z
im->SetRegions( region );
//im->SetSpacing(spacing);
im->Allocate();
im->FillBuffer(0);
im->Update();
//copy the input image into the ITK image
typedef itk::ImageRegionIteratorWithIndex< OutputImageType > IteratorType;
IteratorType iterator1(im,im->GetRequestedRegion());
for(int i=0; i<r*c*z; i++)
{
iterator1.Set((float)imgIn[i]);
++iterator1;
}
//apply gradient anisotropic diffusion
typedef itk::GradientAnisotropicDiffusionImageFilter< OutputImageType, OutputImageType > FilterType;
FilterType::Pointer filter = FilterType::New();
filter->SetInput( im );
filter->SetNumberOfIterations( iter );
filter->SetTimeStep( timeStep );
filter->SetConductanceParameter( comductance );
try
{
filter->Update();
}
catch( itk::ExceptionObject & err )
{
std::cerr << err << std::endl;
return 0;
}
typedef itk::RescaleIntensityImageFilter< OutputImageType, InputImageType > RescaleFilterType;
RescaleFilterType::Pointer rescaler = RescaleFilterType::New();
rescaler->SetOutputMinimum( 0 );
rescaler->SetOutputMaximum( 255 );
rescaler->SetInput( filter->GetOutput() );
rescaler->Update();
//overwrite the input image for now in order to save space
typedef itk::ImageRegionIteratorWithIndex< InputImageType > IteratorType2;
IteratorType2 iterator2(rescaler->GetOutput(),rescaler->GetOutput()->GetRequestedRegion());
for(int i=0; i<r*c*z; i++)
{
imgIn[i] = iterator2.Get();
++iterator2;
}
return 1;
}
//
//###########################################################################
// RunTest
//###########################################################################
//
bool
TreeTestNode::RunTest()
{
TreeTestPlug *testPlug1, *testPlug2;
int values[TEST_COUNT];
int i, j;
// Time startTicks;
/*
* Generate unique values, shuffle them
*/
for (i = 0; i < TEST_COUNT; i++) {
values[i] = i;
}
for (i = 0; i < TEST_COUNT; i++) {
int tmp;
j = i + Random::GetLessThan(TEST_COUNT - i);
tmp = values[j];
values[j] = values[i];
values[i] = tmp;
}
//
//--------------------------------------------------------------------
// Stress tests
//--------------------------------------------------------------------
//
/*
* Create plugs and add to both sockets
*/
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new TreeTestPlug(values[i]);
Register_Object(testPlug1);
tree1.AddValue(testPlug1, values[i]);
tree2.AddValue(testPlug1, values[i]);
}
TestOrder();
/*
* Find
*/
{
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = tree1.Find(i);
testPlug2 = tree2.Find(i);
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
Test_Assumption( testPlug1 == testPlug2 );
}
}
/*
* Test_Assumption first and last
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
iterator1.First();
iterator2.First();
testPlug1 = iterator1.GetCurrent();
testPlug2 = iterator2.GetCurrent();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1 == iterator1.GetNth(0) );
Test_Assumption( testPlug1 == iterator2.GetNth(0) );
}
/*
* Test_Assumption next and prev
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.GetCurrent()) != NULL)
{
testPlug2 = iterator2.GetCurrent();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
iterator1.Next();
iterator2.Next();
i++;
}
Test_Assumption( i == TEST_COUNT );
}
/*
* Test_Assumption read next and read prev
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
{
testPlug2 = iterator2.ReadAndNext();
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
i++;
}
Test_Assumption( i == TEST_COUNT );
}
/*
* Test_Assumption nth
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = iterator1.GetNth(i);
testPlug2 = iterator2.GetNth(i);
Test_Assumption( testPlug1 == testPlug2 );
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
}
}
/*
* Test_Assumption Remove
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.GetCurrent()) != NULL)
{
Test_Assumption( testPlug1->value == i );
iterator1.Remove();
testPlug2 = iterator2.GetNth(0);
Test_Assumption( testPlug2->value == i );
Test_Assumption( testPlug1 == testPlug2 );
Unregister_Object(testPlug2);
delete testPlug2;
i++;
TestOrder();
}
Test_Assumption( i == TEST_COUNT );
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
}
/*
* Test_Assumption random deletion
*/
/*
* Add plugs to both sockets
*/
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new TreeTestPlug(values[i]);
Register_Object( testPlug1 );
tree1.AddValue(testPlug1, values[i]);
tree2.AddValue(testPlug1, values[i]);
TestOrder();
}
TestOrder();
}
/*
* Perform random deletion
*/
{
int size, index;
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while((size = iterator1.GetSize()) != 0)
{
index = Random::GetLessThan(size);
testPlug1 = iterator1.GetNth(index);
iterator1.Remove();
testPlug2 = iterator2.GetNth(index);
Test_Assumption( testPlug1 == testPlug2 );
Unregister_Object( testPlug2 );
delete(testPlug2);
i++;
TestOrder();
}
Test_Assumption( i == TEST_COUNT );
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
}
return true;
}
//
//###########################################################################
// RunProfile
//###########################################################################
//
bool
TreeTestNode::RunProfile()
{
TreeTestPlug *testPlug1, *testPlug2;
int values[TEST_COUNT];
int i, j;
Time startTicks;
/*
* Generate unique values, shuffle them
*/
for (i = 0; i < TEST_COUNT; i++) {
values[i] = i;
}
for (i = 0; i < TEST_COUNT; i++) {
int tmp;
j = i + Random::GetLessThan(TEST_COUNT - i);
tmp = values[j];
values[j] = values[i];
values[i] = tmp;
}
//
//--------------------------------------------------------------------
// Run timing tests
//--------------------------------------------------------------------
//
/*
* Create plugs and add to both sockets
*/
startTicks = gos_GetHiResTime();
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = new TreeTestPlug(values[i]);
Register_Object( testPlug1 );
tree1.AddValue(testPlug1, values[i]);
tree2.AddValue(testPlug1, values[i]);
}
SPEW((
GROUP_STUFF_TEST,
"TreeTestNode::RunTest Create = %f",
gos_GetHiResTime() - startTicks
));
/*
* Iterate over both sockets
*/
startTicks = gos_GetHiResTime();
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
{
Test_Assumption( testPlug1->value == i );
i++;
}
Test_Assumption( i == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator2.ReadAndNext()) != NULL)
{
Test_Assumption( testPlug1->value == i );
i++;
}
Test_Assumption( i == TEST_COUNT );
}
SPEW((
GROUP_STUFF_TEST,
"TreeTestNode::RunTest Iterate = %f",
gos_GetHiResTime() - startTicks
));
/*
* Find
*/
startTicks = gos_GetHiResTime();
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
for (i = 0; i < TEST_COUNT; i++)
{
testPlug1 = iterator1.Find(i);
testPlug2 = iterator2.Find(i);
Test_Assumption( testPlug1->value == i );
Test_Assumption( testPlug2->value == i );
Test_Assumption( testPlug1 == testPlug2 );
}
}
SPEW((
GROUP_STUFF_TEST,
"TreeTestNode::RunTest Find = %f",
gos_GetHiResTime() - startTicks
));
/*
* Destroy from tree1, verify with tree2
*/
startTicks = gos_GetHiResTime();
{
TreeIteratorOf<TreeTestPlug*, int> iterator1(&tree1);
TreeIteratorOf<TreeTestPlug*, int> iterator2(&tree2);
Test_Assumption( iterator1.GetSize() == TEST_COUNT );
Test_Assumption( iterator2.GetSize() == TEST_COUNT );
i = 0;
while ((testPlug1 = iterator1.ReadAndNext()) != NULL)
{
Test_Assumption( testPlug1->value == i );
i++;
Unregister_Object(testPlug1);
delete(testPlug1);
}
Test_Assumption( i == TEST_COUNT );
Test_Assumption( iterator1.GetSize() == 0 );
Test_Assumption( iterator2.GetSize() == 0 );
}
SPEW((
GROUP_STUFF_TEST,
"TreeTestNode::RunTest Destroy = %f",
gos_GetHiResTime() - startTicks
));
return true;
}