Actually put in working implementation of GetSerialConnections

          if (!cm->IsIgnored()) {

            QString sn = cm->GetCubeSerialNumber();

            // new graph:

            ImageConnection connection = boost::add_edge(m_vertexMap[serial],

                                                         m_vertexMap[sn],

                                                         m_controlGraph).first;

  QList< QList< QString > > ControlNet::GetSerialConnections() const {

    QList< QList< QString > > islandStrings;

  //  std::vector<int> component (boost::num_vertices (m_controlGraph));

    VertexIndexMap indexMap;

    VertexIndexMapAdaptor indexMapAdaptor(indexMap);

    size_t numComponents = boost::connected_components(m_controlGraph, componentAdaptor,

                                                      boost::vertex_index_map(indexMapAdaptor));

    std::cout << "Vertices in the first component:" << std::endl;

    std::cout << numComponents << std::endl; 

    for (size_t i = 0; i < numComponents; ++i){

      if (componentAdaptor[i] == 0)

        std::cout << i << " ";

//    std::cout << "Number of components:" << std::endl;

//    std::cout << numComponents << std::endl; 

//    std::cout << "Size of return: " << componentMap.size() << std::endl; 

    // This is not efficient, but works

    QHash<int, QList<QString> > islandsByGroup; 

    std::map<ImageVertex, size_t>::iterator it = componentMap.begin();

    while(it != componentMap.end())

    {

      ImageVertex vertex = it->first;

      QString serial = m_controlGraph[vertex].serial;

      int group = (int) it->second;

 //     std::cout << group << "  ::  "  << serial << std::endl; 

      islandsByGroup[group].append(serial); 

      ++it;

    }

    QList< QList< ControlCubeGraphNode * > > islands;// = m_controlGraph.

    for (int i = 0; i < islands.size(); i++) {

      QList< QString > newIsland;

      islandStrings.append(newIsland);

      for (int j = 0; j < islands[i].size(); j++)

        islandStrings[i].append(islands[i][j]->getSerialNumber());

//   std::cout << std::endl; 

    QList<int> groups = islandsByGroup.keys();

    for (int i=0; i<groups.size(); i++) {

      std::cout << "Group: " << groups[i] << std::endl; 

      QList<QString> temp = islandsByGroup[groups[i]];

      islandStrings.append(temp); // <--- this converts to the output format;

      for (int j=0; j<temp.size();j++) {

        std::cout << " ----- " << temp[j] << std::endl; 

      }

    }

    return islandStrings;

  }

      //! hash ControlPoints by ControlPoint Id

      QHash< QString, ControlPoint * > * points;

      //! hash ControlCubeGraphNodes by CubeSerialNumber

      // structs and typedefs for the boost graph

      struct Image {

        QString serial;

      typedef std::map<ImageVertex, size_t> VertexIndexMap;

      typedef boost::associative_property_map<VertexIndexMap> VertexIndexMapAdaptor;

      typedef Network::out_edge_iterator ConnectionIterator;

      QHash<QString, ImageVertex> m_vertexMap; //!< The SN -> vertex hash for the boost graph

      Network m_controlGraph; //!< The boost graph

      QStringList *pointIds;

      QMutex *m_mutex;