void test_phasingcorrection(UnitTest &ut) {

  ut.begin_test_set("PhasingCorrection");

  Cluster<double> c1;
  c1.add_signal("RAW");
  c1.signal("RAW").push_back(ReadIntensity<double>(1000 ,0,0,0   ));
  c1.signal("RAW").push_back(ReadIntensity<double>(500  ,0,0,2000));
  c1.signal("RAW").push_back(ReadIntensity<double>(250  ,0,0,2000));
  c1.signal("RAW").push_back(ReadIntensity<double>(125  ,0,0,2000));
  c1.signal("RAW").push_back(ReadIntensity<double>(62.5 ,0,0,2000));
  c1.signal("RAW").push_back(ReadIntensity<double>(31.25,0,0,2000));

  vector<Cluster<double> > clusters;
  clusters.push_back(c1);

  PhasingCorrection<double> m_phasing_correction(0,0.5,0.6,"RAW","PHASE_CORRECTED");
  m_phasing_correction.process(clusters);
  
  ut.test(clusters[0].signal("PHASE_CORRECTED")[0],ReadIntensity<double>(1968.75,0,0,0));
  ut.test(clusters[0].signal("PHASE_CORRECTED")[1],ReadIntensity<double>(0      ,0,0,2000));
  ut.test(clusters[0].signal("PHASE_CORRECTED")[2],ReadIntensity<double>(0      ,0,0,2000));
  ut.test(clusters[0].signal("PHASE_CORRECTED")[3],ReadIntensity<double>(0      ,0,0,2000));
  ut.test(clusters[0].signal("PHASE_CORRECTED")[4],ReadIntensity<double>(0      ,0,0,2000));
  ut.test(clusters[0].signal("PHASE_CORRECTED")[5],ReadIntensity<double>(0      ,0,0,2000));

  ut.end_test_set();
}
Beispiel #2
0
int test_tialloc(UnitTest &utf) {

    utf.begin_test_set("tialloc tests");

    test_tialloc_size10(utf);
    test_tialloc_size5to10(utf);
    test_tialloc_random(utf);

    utf.end_test_set();
}
void test_adaptivethreshold(UnitTest &ut) {

  ut.begin_test_set("AdaptiveThreshold");
/*
  SwiftImage<uint16> img("./Images/tiny5dot.tif");
  AdaptiveThreshold<uint16> at(1,0.7,AdaptiveThreshold<uint16>::mask_type_circle);
  SwiftImage<uint16> imgat = at.process(img);
  ut.test(imgat(0,0),static_cast<uint16>(0));
  ut.test(imgat(1,0),static_cast<uint16>(0));
  ut.test(imgat(2,0),static_cast<uint16>(0));
  ut.test(imgat(3,0),static_cast<uint16>(0));
  ut.test(imgat(4,0),static_cast<uint16>(0));

  ut.test(imgat(0,1),static_cast<uint16>(0));
  ut.test(imgat(1,1),static_cast<uint16>(65534));
  ut.test(imgat(2,1),static_cast<uint16>(65534));
  ut.test(imgat(3,1),static_cast<uint16>(65534));
  ut.test(imgat(4,1),static_cast<uint16>(0));

  ut.test(imgat(0,2),static_cast<uint16>(0));
  ut.test(imgat(1,2),static_cast<uint16>(65534));
  ut.test(imgat(2,2),static_cast<uint16>(0));
  ut.test(imgat(3,2),static_cast<uint16>(65534));
  ut.test(imgat(4,2),static_cast<uint16>(0));

  ut.test(imgat(0,3),static_cast<uint16>(0));
  ut.test(imgat(1,3),static_cast<uint16>(65534));
  ut.test(imgat(2,3),static_cast<uint16>(65534));
  ut.test(imgat(3,3),static_cast<uint16>(65534));
  ut.test(imgat(4,3),static_cast<uint16>(0));

  ut.test(imgat(0,4),static_cast<uint16>(0));
  ut.test(imgat(1,4),static_cast<uint16>(0));
  ut.test(imgat(2,4),static_cast<uint16>(0));
  ut.test(imgat(3,4),static_cast<uint16>(0));
  ut.test(imgat(4,4),static_cast<uint16>(0));

  SwiftImage<uint16> i2("./Images/run475_lane1tile1/C2.1/s_1_1_a.tif");
  MorphologicalOpening<uint16> mo(4);
  SwiftImage<uint16> i4 = mo.process(i2);
 
  i2 = i2 - i4;
  SwiftImage<uint16> i3 = at.process(i2);
  

  i3.save("./adaptive_morph.tif");
*/
  ut.end_test_set();
}
void test_runlengthencode(UnitTest &ut) {

  ut.begin_test_set("RunLengthEncode");

  SwiftImage<uint16> img("./Images/tinyline.tif");
  RunLengthEncode<uint16> rle;

  vector<RLERun<> > runs = rle.process(img);
 
  ut.test(static_cast<int>(runs.size())   ,1);
  ut.test(runs[0].pos.x ,2);
  ut.test(runs[0].pos.y ,1);
  ut.test(runs[0].length,9);

  ut.end_test_set();
}
Beispiel #5
0
void test_reporting(UnitTest &ut) {

  ut.begin_test_set("Reporting");

  Cluster<double> c1;
  
  c1.add_signal("RAW");
  c1.signal("RAW").push_back(ReadIntensity<double>(1000 ,0,0,0   ));
  c1.signal("RAW").push_back(ReadIntensity<double>(500  ,0,0,2000));
  c1.signal("RAW").push_back(ReadIntensity<double>(250  ,0,0,2000));
  c1.signal("RAW").push_back(ReadIntensity<double>(125  ,0,0,2000));
  c1.signal("RAW").push_back(ReadIntensity<double>(62.5 ,0,0,2000));
  c1.signal("RAW").push_back(ReadIntensity<double>(31.25,0,0,2000));
  
  c1.add_signal("FINAL_CORRECTED");
  c1.signal("FINAL_CORRECTED").push_back(ReadIntensity<double>(1000 ,0,0,0   ));
  c1.signal("FINAL_CORRECTED").push_back(ReadIntensity<double>(500  ,0,0,2000));
  c1.signal("FINAL_CORRECTED").push_back(ReadIntensity<double>(250  ,0,0,2000));
  c1.signal("FINAL_CORRECTED").push_back(ReadIntensity<double>(125  ,0,0,2000));
  c1.signal("FINAL_CORRECTED").push_back(ReadIntensity<double>(62.5 ,0,0,2000));
  c1.signal("FINAL_CORRECTED").push_back(ReadIntensity<double>(31.25,0,0,2000));

  c1.add_sequence("BASECALL_FINAL");
  //TODO: I'm really unclear as to why I need this cast, for some reason gcc can't see base_type from here...
  c1.sequence("BASECALL_FINAL").sequence().push_back(static_cast<int>(ScoredSequence<>::base_a));
  c1.sequence("BASECALL_FINAL").sequence().push_back(static_cast<int>(ScoredSequence<>::base_t));
  c1.sequence("BASECALL_FINAL").sequence().push_back(static_cast<int>(ScoredSequence<>::base_t));
  c1.sequence("BASECALL_FINAL").sequence().push_back(static_cast<int>(ScoredSequence<>::base_t));
  c1.sequence("BASECALL_FINAL").sequence().push_back(static_cast<int>(ScoredSequence<>::base_t));
  c1.sequence("BASECALL_FINAL").sequence().push_back(static_cast<int>(ScoredSequence<>::base_t));
  
  vector<Cluster<double> > clusters;
  clusters.push_back(c1);
  clusters.push_back(c1);
  clusters.push_back(c1);
  clusters.push_back(c1);
  clusters.push_back(c1);
  clusters.push_back(c1);

  Reporting<double> m_reporting(clusters,true,"./phi_plus_SNPs.fa");

  m_reporting.write_report_file("report");

  ut.end_test_set();
}
Beispiel #6
0
void test_channeloffsets(UnitTest &ut) {

  int size=100;
  int num_cycles=10;
  ut.begin_test_set("ChannelOffsets");
  ChannelOffsets<uint16> co_fft   (ChannelOffsets<uint16>::fft);
  ChannelOffsets<uint16> co_simple(ChannelOffsets<uint16>::simple,size);

  vector<SwiftImage<uint16> > images;

  int size_x=size;
  int size_y=size;

  srand(12345);

  for(int n=0;n<num_cycles;n++) {
    SwiftImage<uint16> rnd(size_x,size_y);
    
    for(int r=0; r<2500; r++) {
      int x = rand() % size_x;
      int y = rand() % size_y;

      rnd(x,y) = rand() % 32768;
    }

    images.push_back(rnd);
  }
  
  co_fft   .process(images[0],images,num_cycles);
  co_simple.process(images[0],images,num_cycles);
  
  for(int n=0;n<co_fft.get_offsets().size();n++) {
    ut.test(co_fft.get_offsets()[n].x,co_simple.get_offsets()[n].x);
    ut.test(co_fft.get_offsets()[n].y,co_simple.get_offsets()[n].y);
  }

  ut.end_test_set();
}
void test_euclideandistancemap(UnitTest &ut) {

  ut.begin_test_set("EuclideanDistanceMap");

  EuclideanDistanceMap<uint16> edm;
  
  SwiftImage<uint16> i10("./Images/tiny10.tif");
  SwiftImage<uint16> i10_edm = edm.process(i10);
  
  ut.test(i10_edm(0,0),static_cast<uint16>(0));
  ut.test(i10_edm(0,1),static_cast<uint16>(0));
  ut.test(i10_edm(0,2),static_cast<uint16>(0));
  ut.test(i10_edm(0,3),static_cast<uint16>(0));
  ut.test(i10_edm(0,4),static_cast<uint16>(0));
  ut.test(i10_edm(0,5),static_cast<uint16>(0));
  ut.test(i10_edm(0,6),static_cast<uint16>(0));
  ut.test(i10_edm(0,7),static_cast<uint16>(0));
  ut.test(i10_edm(0,8),static_cast<uint16>(0));
  ut.test(i10_edm(0,9),static_cast<uint16>(0));
  
  ut.test(i10_edm(1,0),static_cast<uint16>(0));
  ut.test(i10_edm(1,1),static_cast<uint16>(1));
  ut.test(i10_edm(1,2),static_cast<uint16>(1));
  ut.test(i10_edm(1,3),static_cast<uint16>(1));
  ut.test(i10_edm(1,4),static_cast<uint16>(1));
  ut.test(i10_edm(1,5),static_cast<uint16>(1));
  ut.test(i10_edm(1,6),static_cast<uint16>(1));
  ut.test(i10_edm(1,7),static_cast<uint16>(1));
  ut.test(i10_edm(1,8),static_cast<uint16>(1));
  ut.test(i10_edm(1,9),static_cast<uint16>(0));
  
  ut.test(i10_edm(2,0),static_cast<uint16>(0));
  ut.test(i10_edm(2,1),static_cast<uint16>(1));
  ut.test(i10_edm(2,2),static_cast<uint16>(2));
  ut.test(i10_edm(2,3),static_cast<uint16>(2));
  ut.test(i10_edm(2,4),static_cast<uint16>(2));
  ut.test(i10_edm(2,5),static_cast<uint16>(2));
  ut.test(i10_edm(2,6),static_cast<uint16>(2));
  ut.test(i10_edm(2,7),static_cast<uint16>(2));
  ut.test(i10_edm(2,8),static_cast<uint16>(1));
  ut.test(i10_edm(2,9),static_cast<uint16>(0));
  
  ut.test(i10_edm(3,0),static_cast<uint16>(0));
  ut.test(i10_edm(3,1),static_cast<uint16>(1));
  ut.test(i10_edm(3,2),static_cast<uint16>(2));
  ut.test(i10_edm(3,3),static_cast<uint16>(3));
  ut.test(i10_edm(3,4),static_cast<uint16>(3));
  ut.test(i10_edm(3,5),static_cast<uint16>(3));
  ut.test(i10_edm(3,6),static_cast<uint16>(3));
  ut.test(i10_edm(3,7),static_cast<uint16>(2));
  ut.test(i10_edm(3,8),static_cast<uint16>(1));
  ut.test(i10_edm(3,9),static_cast<uint16>(0));
  
  ut.test(i10_edm(4,0),static_cast<uint16>(0));
  ut.test(i10_edm(4,1),static_cast<uint16>(1));
  ut.test(i10_edm(4,2),static_cast<uint16>(2));
  ut.test(i10_edm(4,3),static_cast<uint16>(3));
  ut.test(i10_edm(4,4),static_cast<uint16>(4));
  ut.test(i10_edm(4,5),static_cast<uint16>(4));
  ut.test(i10_edm(4,6),static_cast<uint16>(3));
  ut.test(i10_edm(4,7),static_cast<uint16>(2));
  ut.test(i10_edm(4,8),static_cast<uint16>(1));
  ut.test(i10_edm(4,9),static_cast<uint16>(0));
 
  ut.test(i10_edm(5,0),static_cast<uint16>(0));
  ut.test(i10_edm(5,1),static_cast<uint16>(1));
  ut.test(i10_edm(5,2),static_cast<uint16>(2));
  ut.test(i10_edm(5,3),static_cast<uint16>(3));
  ut.test(i10_edm(5,4),static_cast<uint16>(4));
  ut.test(i10_edm(5,5),static_cast<uint16>(4));
  ut.test(i10_edm(5,6),static_cast<uint16>(3));
  ut.test(i10_edm(5,7),static_cast<uint16>(2));
  ut.test(i10_edm(5,8),static_cast<uint16>(1));
  ut.test(i10_edm(5,9),static_cast<uint16>(0));
  
  ut.test(i10_edm(6,0),static_cast<uint16>(0));
  ut.test(i10_edm(6,1),static_cast<uint16>(1));
  ut.test(i10_edm(6,2),static_cast<uint16>(2));
  ut.test(i10_edm(6,3),static_cast<uint16>(3));
  ut.test(i10_edm(6,4),static_cast<uint16>(3));
  ut.test(i10_edm(6,5),static_cast<uint16>(3));
  ut.test(i10_edm(6,6),static_cast<uint16>(3));
  ut.test(i10_edm(6,7),static_cast<uint16>(2));
  ut.test(i10_edm(6,8),static_cast<uint16>(1));
  ut.test(i10_edm(6,9),static_cast<uint16>(0));
  
  ut.test(i10_edm(7,0),static_cast<uint16>(0));
  ut.test(i10_edm(7,1),static_cast<uint16>(1));
  ut.test(i10_edm(7,2),static_cast<uint16>(2));
  ut.test(i10_edm(7,3),static_cast<uint16>(2));
  ut.test(i10_edm(7,4),static_cast<uint16>(2));
  ut.test(i10_edm(7,5),static_cast<uint16>(2));
  ut.test(i10_edm(7,6),static_cast<uint16>(2));
  ut.test(i10_edm(7,7),static_cast<uint16>(2));
  ut.test(i10_edm(7,8),static_cast<uint16>(1));
  ut.test(i10_edm(7,9),static_cast<uint16>(0));
  
  ut.test(i10_edm(8,0),static_cast<uint16>(0));
  ut.test(i10_edm(8,1),static_cast<uint16>(1));
  ut.test(i10_edm(8,2),static_cast<uint16>(1));
  ut.test(i10_edm(8,3),static_cast<uint16>(1));
  ut.test(i10_edm(8,4),static_cast<uint16>(1));
  ut.test(i10_edm(8,5),static_cast<uint16>(1));
  ut.test(i10_edm(8,6),static_cast<uint16>(1));
  ut.test(i10_edm(8,7),static_cast<uint16>(1));
  ut.test(i10_edm(8,8),static_cast<uint16>(1));
  ut.test(i10_edm(8,9),static_cast<uint16>(0));
  
  ut.test(i10_edm(9,0),static_cast<uint16>(0));
  ut.test(i10_edm(9,1),static_cast<uint16>(0));
  ut.test(i10_edm(9,2),static_cast<uint16>(0));
  ut.test(i10_edm(9,3),static_cast<uint16>(0));
  ut.test(i10_edm(9,4),static_cast<uint16>(0));
  ut.test(i10_edm(9,5),static_cast<uint16>(0));
  ut.test(i10_edm(9,6),static_cast<uint16>(0));
  ut.test(i10_edm(9,7),static_cast<uint16>(0));
  ut.test(i10_edm(9,8),static_cast<uint16>(0));
  ut.test(i10_edm(9,9),static_cast<uint16>(0));
  
  // Trying things out...
/*  NWThreshold<uint16> nwt(5,0.5,2000,NWThreshold<uint16>::mask_type_square);//0.75 beautiful

  SwiftImage<uint16> i1("./Images/run475_lane1tile1/C2.1/s_1_1_a.tif");
  SwiftImage<uint16> i2 = nwt.process(i1);

  SwiftImage<uint16> i3 = edm.process(i2);
  i3.save("edm.tiff");
*/
  ut.end_test_set();
}
void test_crosschannelregistration(UnitTest &ut) {

  ut.begin_test_set("CrossChannelRegistration");

  Segmentation<uint16> segmenter;

  EuclideanDistanceMap<uint16> edm;
  Watershed<uint16> wat;
  Invert<uint16> inv;
  NWThreshold<uint16> nwt(5,0.5,60000,NWThreshold<uint16>::mask_type_square);//0.75 beautiful

  SwiftImage<uint16> c1a_i1("./Images/smallfake2/c1_a.tif");
  cout << "Load complete" << endl;
  SwiftImage<uint16> c1a_i2 = nwt.process(c1a_i1);
  cout << "Thresholding complete" << endl;
  SwiftImage<uint16> c1a_i3 = edm.process(c1a_i2);
  cout << "EDM complete" << endl;
  SwiftImage<uint16> c1a_i4 = inv.process(c1a_i3);
  cout << "INV complete" << endl;
  SwiftImage<uint16> c1a_i5 = wat.process(c1a_i4);
  cout << "Wat complete" << endl;
  SwiftImage<uint16> c1a_i6 = c1a_i2 && c1a_i5;
  vector<SwiftImageObject<> > c1a_objs1 = segmenter.process(c1a_i6);
  
  SwiftImage<uint16> c2a_i1("./Images/smallfake2/c2_a.tif");
  cout << "Load complete" << endl;
  SwiftImage<uint16> c2a_i2 = nwt.process(c2a_i1);
  cout << "Thresholding complete" << endl;
  SwiftImage<uint16> c2a_i3 = edm.process(c2a_i2);
  cout << "EDM complete" << endl;
  SwiftImage<uint16> c2a_i4 = inv.process(c2a_i3);
  cout << "INV complete" << endl;
  SwiftImage<uint16> c2a_i5 = wat.process(c2a_i4);
  cout << "Wat complete" << endl;
  SwiftImage<uint16> c2a_i6 = c2a_i2 && c2a_i5;
  vector<SwiftImageObject<> > c2a_objs1 = segmenter.process(c2a_i6);
  
  SwiftImage<uint16> c1t_i1("./Images/smallfake2/c1_t.tif");
  cout << "Load complete" << endl;
  SwiftImage<uint16> c1t_i2 = nwt.process(c1t_i1);
  cout << "Thresholding complete" << endl;
  SwiftImage<uint16> c1t_i3 = edm.process(c1t_i2);
  cout << "EDM complete" << endl;
  SwiftImage<uint16> c1t_i4 = inv.process(c1t_i3);
  cout << "INV complete" << endl;
  SwiftImage<uint16> c1t_i5 = wat.process(c1t_i4);
  cout << "Wat complete" << endl;
  SwiftImage<uint16> c1t_i6 = c1t_i2 && c1t_i5;
  vector<SwiftImageObject<> > c1t_objs1 = segmenter.process(c1t_i6);
  
  SwiftImage<uint16> c2t_i1("./Images/smallfake2/c2_t.tif");
  cout << "Load complete" << endl;
  SwiftImage<uint16> c2t_i2 = nwt.process(c2t_i1);
  cout << "Thresholding complete" << endl;
  SwiftImage<uint16> c2t_i3 = edm.process(c2t_i2);
  cout << "EDM complete" << endl;
  SwiftImage<uint16> c2t_i4 = inv.process(c2t_i3);
  cout << "INV complete" << endl;
  SwiftImage<uint16> c2t_i5 = wat.process(c2t_i4);
  cout << "Wat complete" << endl;
  SwiftImage<uint16> c2t_i6 = c2t_i2 && c2t_i5;
  vector<SwiftImageObject<> > c2t_objs1 = segmenter.process(c2t_i6);
  
 
  // Now have c1_objs1 and c2_objs1 for registration

  vector<vector<SwiftImageObject<> > > a_cycles;
  a_cycles.push_back(c1a_objs1);
  a_cycles.push_back(c2a_objs1);
  
  vector<vector<SwiftImageObject<> > > t_cycles;
  t_cycles.push_back(c1t_objs1);
  t_cycles.push_back(c2t_objs1);

  ChannelRegistration<> chanreg(c2a_i6.image_width(),c2a_i6.image_height());
  vector<vector<SwiftImageCluster<> > > a_clusters = chanreg.process_channel_registration(a_cycles,SwiftImageCluster<>::base_a);
  vector<vector<SwiftImageCluster<> > > c_clusters = chanreg.process_channel_registration(t_cycles,SwiftImageCluster<>::base_c);
  vector<vector<SwiftImageCluster<> > > g_clusters = chanreg.process_channel_registration(a_cycles,SwiftImageCluster<>::base_g);
  vector<vector<SwiftImageCluster<> > > t_clusters = chanreg.process_channel_registration(t_cycles,SwiftImageCluster<>::base_t);
 
  CrossChannelRegistration<> crosschanreg(c2a_i6.image_width(),c2a_i6.image_height(),true,3);
  vector<vector<SwiftImageCluster<> > > all_clusters = crosschanreg.process_crosschannel_registration(a_clusters,
                                                                                                      c_clusters,
                                                                                                      g_clusters,
                                                                                                      t_clusters);


  for(int n=0;n<all_clusters.size();n++) {
    ut.test(static_cast<int>(all_clusters[n].size()),2);
  }
   
  ut.test(static_cast<int>(all_clusters.size()),5);
  
  // Cluster 1, Cycle 1
  ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  

  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  

  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  // Cluster 1, Cycle 2
  ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  

  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  

  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  // Cluster 2, Cycle 1
  ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_a].size()),2);
  ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_g].size()),2);
  ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_c].size()),1);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  
  // Cluster 2, Cycle 2
  ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_c].size()),1);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,6);

  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,6);
   
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,6);
 

  // Cluster 3, Cycle 1
  ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,2);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
  
  // Cluster 3, Cycle 2
  ut.test(static_cast<int>(all_clusters[2][1].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[2][1].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[2][1].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[2][1].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,2);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  // Cluster 4, Cycle 1
  ut.test(static_cast<int>(all_clusters[3][0].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[3][0].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[3][0].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[3][0].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,8);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,8);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,8);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,8);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,8);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,8);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
  
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,8);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,8);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
  ut.test(all_clusters[3][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
 
  // Cluster 4, Cycle 2
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,8);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,8);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,8);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,8);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,8);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,8);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
  
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,8);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,8);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
  ut.test(all_clusters[3][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
 
  
  all_clusters = crosschanreg.process_crosschannel_registration_inv(a_clusters,
                                                                    c_clusters,
                                                                    g_clusters,
                                                                    t_clusters);
  
  for(int n=0;n<all_clusters.size();n++) {
    ut.test(static_cast<int>(all_clusters[n].size()),2);
  }
   
  ut.test(static_cast<int>(all_clusters.size()),5);
  
  // Cluster 1, Cycle 1
  ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[0][0].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  

  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  

  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  // Cluster 1, Cycle 2
  ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[0][1].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  

  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  

  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[0][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  // Cluster 2, Cycle 1
  ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_a].size()),2);
  ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_g].size()),2);
  ut.test(static_cast<int>(all_clusters[1][0].features[SwiftImageCluster<>::base_c].size()),1);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_a][1].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_g][1].pixels[1].length,2);

  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  
  // Cluster 2, Cycle 2
  ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[1][1].features[SwiftImageCluster<>::base_c].size()),1);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,6);

  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,6);
   
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,6);
  
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,1);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
  ut.test(all_clusters[1][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,6);
 

  // Cluster 3, Cycle 1
  ut.test(static_cast<int>(all_clusters[4][0].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[4][0].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[4][0].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[4][0].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,5);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,5);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,5);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,5);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,2);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
  
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[4][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
  
  // Cluster 3, Cycle 2
  ut.test(static_cast<int>(all_clusters[4][1].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[4][1].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[4][1].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[4][1].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,5);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,1);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,5);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,2);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,5);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,1);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,5);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,2);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,5);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,1);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,5);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,2);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
  
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,5);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,1);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,5);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,2);
  ut.test(all_clusters[4][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  // Cluster 4, Cycle 1
  ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_a].size()),1);
  ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_t].size()),1);
  ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_g].size()),1);
  ut.test(static_cast<int>(all_clusters[2][0].features[SwiftImageCluster<>::base_c].size()),1);

  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,8);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,8);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,8);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,8);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,8);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,8);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,8);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,8);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
  ut.test(all_clusters[2][0].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);
 
  // Cluster 4, Cycle 2
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.x,8);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].pos.y,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.x,8);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].pos.y,6);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_a][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.x,8);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].pos.y,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.x,8);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].pos.y,6);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_t][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.x,8);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].pos.y,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[0].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.x,8);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].pos.y,6);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_g][0].pixels[1].length,2);
  
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.x,8);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].pos.y,5);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[0].length,2);
 
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.x,8);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].pos.y,6);
  ut.test(all_clusters[2][1].features[SwiftImageCluster<>::base_c][0].pixels[1].length,2);

  ut.end_test_set();
}