multi_line.cpp

Go to the documentation of this file.

 
/*===============================================================================================================================
 
This file is part of CoastalME, the Coastal Modelling Environment.
 
CoastalME is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
===============================================================================================================================*/
#include <assert.h>
 
#include "cme.h"
#include "multi_line.h"

CGeomMultiLine::CGeomMultiLine(void)
{
}

CGeomMultiLine::~CGeomMultiLine(void)
{
}

void CGeomMultiLine::AppendLineSegment(void)
{
   m_prVVLineSegment.push_back(vector<pair<int, int> >());
}

void CGeomMultiLine::AppendLineSegment(vector<pair<int, int> >* pprVIn)
{
   m_prVVLineSegment.push_back(*pprVIn);
}

// void CGeomMultiLine::AppendLineSegmentAndInherit(void)
// {
//    vector<pair<int, int> > prVNewLineSeg;
//    m_prVVLineSegment.push_back(prVNewLineSeg);
//
//    // Must inherit any profile numbers stored in earlier (i.e. coastward) line segments
//    int nSize = m_prVVLineSegment.size();
//    if (nSize > 1)
//    {
//       for (int n = 0; n < m_prVVLineSegment[nSize-2].size(); n++)
//       {
//          int
//             nPrevProfile = m_prVVLineSegment[nSize-2][n].first,
//             nPrevLineSeg = m_prVVLineSegment[nSize-2][n].second + 1;
//
//          m_prVVLineSegment[nSize-1].push_back(make_pair(nPrevProfile, nPrevLineSeg));
//       }
//    }
// }

int CGeomMultiLine::nGetNumLineSegments(void) const
{
   return static_cast<int>(m_prVVLineSegment.size());
}

void CGeomMultiLine::TruncateLineSegments(int const nSize)
{
   m_prVVLineSegment.resize(nSize);
}

void CGeomMultiLine::InsertLineSegment(int const nSegment)
{
//   assert(nSegment < m_prVVLineSegment.size());
 
   // The new vector of pairs is identical to the existing vector of pairs i.e. we inherit profile/line seg details from the previous line seg
   vector<pair<int, int> > prVPrev = m_prVVLineSegment[nSegment];
 
   // Store the profile numbers that are in this existing vector of pairs, these are the profiles that will be affected by this insertion
   vector<int> nVProfsAffected;
   for (unsigned int i = 0; i < prVPrev.size(); i++)
      nVProfsAffected.push_back(prVPrev[i].first);
 
   vector<vector<pair<int, int> > >::iterator it;
   it = m_prVVLineSegment.begin();
 
   m_prVVLineSegment.insert(it+nSegment+1, prVPrev);
 
   // Must now increment the profile's own line seg numbers, but only for those profile numbers which were affected by the insertion. Do this for the new line seg and every line seg after that
   for (unsigned int m = nSegment+1; m < m_prVVLineSegment.size(); m++)
   {
      for (unsigned int n = 0; n < m_prVVLineSegment[m].size(); n++)
      {
         for (unsigned int i = 0; i < nVProfsAffected.size(); i++)
         {
            if (m_prVVLineSegment[m][n].first == nVProfsAffected[i])
               m_prVVLineSegment[m][n].second++;
         }
      }
   }
}

vector<vector<pair<int, int> > > CGeomMultiLine::prVVGetAllLineSegAfter(int const nSegment)
{
   vector<vector<pair<int, int> > > prVTmp;
   for (unsigned int n = nSegment; n < m_prVVLineSegment.size(); n++)
      prVTmp.push_back(m_prVVLineSegment[n]);
 
   return prVTmp;
}

void CGeomMultiLine::RemoveLineSegment(int const nSegment)
{
   m_prVVLineSegment.erase(m_prVVLineSegment.begin() + nSegment);
}

void CGeomMultiLine::AppendCoincidentProfileToLineSegments(pair<int, int> const prIn)
{
   long unsigned int nSize = m_prVVLineSegment.size();
   m_prVVLineSegment[nSize-1].push_back(prIn);
//   m_prVVLineSegment.back().push_back(prIn);
}

void CGeomMultiLine::AddCoincidentProfileToExistingLineSegment(int const nSegment, int const nProfile, int const nLineSeg)
{
//   assert(nSegment < m_prVVLineSegment.size());
   m_prVVLineSegment[nSegment].push_back(make_pair(nProfile, nLineSeg));
}

vector<pair<int, int> >* CGeomMultiLine::pprVGetPairedCoincidentProfilesForLineSegment(int const nSegment)
{
   // TODO 055 No check to see if nSegment < size()
   return &m_prVVLineSegment[nSegment];
}

int CGeomMultiLine::nGetCoincidentProfileForLineSegment(int const nSegment, int const nCoinc) const
{
   // Safety check
   if ((nSegment < 0) || (nSegment >= static_cast<int>(m_prVVLineSegment.size())))
      return -1;
 
   // Safety check
   if ((nCoinc < 0) || (nCoinc >= static_cast<int>(m_prVVLineSegment[nSegment].size())))
      return -1;
 
   return m_prVVLineSegment[nSegment][nCoinc].first;
}

int CGeomMultiLine::nGetNumCoincidentProfilesInLineSegment(int const nSegment)
{
   return static_cast<int>(m_prVVLineSegment[nSegment].size());
}

bool CGeomMultiLine::bFindProfileInCoincidentProfilesOfLastLineSegment(int const nProfile)
{
   long unsigned int nLineSegSize = m_prVVLineSegment.size();
 
   // Note no check to ensure that nLineSegSize < 0
   long unsigned int nCoincidentSize = m_prVVLineSegment[nLineSegSize-1].size();
 
   for (unsigned int i = 0; i < nCoincidentSize; i++)
   {
      if (m_prVVLineSegment[nLineSegSize-1][i].first == nProfile)
         return true;
   }
 
   return false;
}

// bool CGeomMultiLine::bFindProfileInCoincidentProfilesOfLineSegment(int const nProfile, int const nSegment)
// {
//    // Note no check to see if nSegment < m_prVVLineSegment.size()
//    int nCoincidentSize = m_prVVLineSegment[nSegment].size();
//
//    for (int i = 0; i < nCoincidentSize; i++)
//       if (m_prVVLineSegment[nSegment][i].first == nProfile)
//          return true;
//
//    return false;
// }

bool CGeomMultiLine::bFindProfileInCoincidentProfiles(int const nProfile)
{
   int nSegSize = static_cast<int>(m_prVVLineSegment.size());
   if (nSegSize == 0)
      return false;
 
   for (int i = nSegSize-1; i >= 0; i--)
   {
      for (unsigned int j = 0; j < m_prVVLineSegment[i].size(); j++)
      {
         if (m_prVVLineSegment[i][j].first == nProfile)
         return true;
      }
   }
 
   return false;
}

void CGeomMultiLine::GetMostCoastwardSharedLineSegment(int const nOtherProfile, int& nThisLineSegment, int& nOtherLineSegment)
{
   nThisLineSegment =
   nOtherLineSegment = -1;
 
   long unsigned int nSegSize = m_prVVLineSegment.size();
   if (nSegSize == 0)
      return;
 
   for (unsigned int i = 0; i < nSegSize; i++)
   {
      for (unsigned int j = 0; j < m_prVVLineSegment[i].size(); j++)
      {
         if (m_prVVLineSegment[i][j].first == nOtherProfile)
         {
            nThisLineSegment = i;
            nOtherLineSegment = m_prVVLineSegment[i][j].second;
 
            return;
         }
      }
   }
}

int CGeomMultiLine::nGetProf(int const nSegment, int const nCoinc) const
{
   return m_prVVLineSegment[nSegment][nCoinc].first;
}

int CGeomMultiLine::nGetProfsLineSeg(int const nSegment, int const nCoinc) const
{
   return m_prVVLineSegment[nSegment][nCoinc].second;
}

void CGeomMultiLine::SetProfsLineSeg(int const nSegment, int const nCoinc, int const nLineSeg)
{
   // Note no check to see if nSegment < m_prVVLineSegment.size() or to see if nCoinc < m_prVVLineSegment[nSegment].size()
   m_prVVLineSegment[nSegment][nCoinc].second = nLineSeg;
}
 
// //! Returns the number of the last line segment which includes the given profile number as a co-incident profile
// int CGeomMultiLine::nFindProfilesLastSeg(int const nProfile) const
// {
//    int nSeg = -1;
//    for (int i = static_cast<int>(m_prVVLineSegment.size()-1); i >= 0; i--)
//    {
//       for (unsigned int j = 0; j < m_prVVLineSegment[i].size(); j++)
//       {
//          if (m_prVVLineSegment[i][j].first == nProfile)
//             nSeg = i;
//       }
//    }
//
//    return nSeg;
// }