profile.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 <cstdio>
 
#include <vector>
using std::vector;
 
#include <algorithm>
using std::find;
 
#include "cme.h"
#include "cell.h"
#include "2d_point.h"
#include "2di_point.h"
#include "multi_line.h"
#include "raster_grid.h"
#include "profile.h"

CGeomProfile::CGeomProfile(int const nCoast, int const nCoastPoint, int const nProfileID, bool const bIntervention)
    : m_bStartOfCoast(false),
      m_bEndOfCoast(false),
      m_bCShoreProblem(false),
      m_bHitLand(false),
      m_bHitIntervention(false),
      m_bHitCoast(false),
      m_bTooShort(false),
      m_bTruncatedSameCoast(false),
      m_bTruncatedDifferentCoast(false),
      m_bHitAnotherProfile(false),
      m_bIntervention(bIntervention),
      m_nCoast(nCoast),
      m_nCoastPoint(nCoastPoint),
      m_nProfileID(nProfileID),
      m_dDeepWaterWaveHeight(0),
      m_dDeepWaterWaveAngle(0),
      m_dDeepWaterWavePeriod(0),
      m_pUpCoastAdjacentProfile(NULL),
      m_pDownCoastAdjacentProfile(NULL)
{
}

CGeomProfile::~CGeomProfile(void)
{
}

int CGeomProfile::nGetCoastID(void) const
{
   return m_nCoast;
}

int CGeomProfile::nGetProfileID(void) const
{
   return m_nProfileID;
}

int CGeomProfile::nGetCoastPoint(void) const
{
   return m_nCoastPoint;
}

CGeom2DIPoint* CGeomProfile::pPtiGetStartPoint(void)
{
   return &m_VCellInProfile.front();
}

CGeom2DIPoint* CGeomProfile::pPtiGetEndPoint(void)
{
   return &m_VCellInProfile.back();
}

void CGeomProfile::SetStartOfCoast(bool const bFlag)
{
   m_bStartOfCoast = bFlag;
}

bool CGeomProfile::bStartOfCoast(void) const
{
   return m_bStartOfCoast;
}

void CGeomProfile::SetEndOfCoast(bool const bFlag)
{
   m_bEndOfCoast = bFlag;
}

bool CGeomProfile::bEndOfCoast(void) const
{
   return m_bEndOfCoast;
}

bool CGeomProfile::bIsGridEdge(void) const
{
   if (m_bStartOfCoast || m_bEndOfCoast)
      return true;
 
   return false;
}

void CGeomProfile::SetCShoreProblem(bool const bFlag)
{
   m_bCShoreProblem = bFlag;
}

bool CGeomProfile::bCShoreProblem(void) const
{
   return m_bCShoreProblem;
}

void CGeomProfile::SetHitLand(bool const bFlag)
{
   m_bHitLand = bFlag;
}

bool CGeomProfile::bHitLand(void) const
{
   return m_bHitLand;
}

void CGeomProfile::SetHitIntervention(bool const bFlag)
{
   m_bHitIntervention = bFlag;
}

bool CGeomProfile::bHitIntervention(void) const
{
   return m_bHitIntervention;
}

void CGeomProfile::SetHitCoast(bool const bFlag)
{
   m_bHitCoast = bFlag;
}

bool CGeomProfile::bHitCoast(void) const
{
   return m_bHitCoast;
}

void CGeomProfile::SetTooShort(bool const bFlag)
{
   m_bTooShort = bFlag;
}

bool CGeomProfile::bTooShort(void) const
{
   return m_bTooShort;
}

void CGeomProfile::SetTruncatedSameCoast(bool const bFlag)
{
   m_bTruncatedSameCoast = bFlag;
}

bool CGeomProfile::bTruncatedSameCoast(void) const
{
   return m_bTruncatedSameCoast;
}

void CGeomProfile::SetTruncatedDifferentCoast(bool const bFlag)
{
   m_bTruncatedDifferentCoast = bFlag;
}

bool CGeomProfile::bTruncatedDifferentCoast(void) const
{
   return m_bTruncatedDifferentCoast;
}

void CGeomProfile::SetHitAnotherProfile(bool const bFlag)
{
   m_bHitAnotherProfile = bFlag;
}

bool CGeomProfile::bHitAnotherProfile(void) const
{
   return m_bHitAnotherProfile;
}

bool CGeomProfile::bProfileOK(void) const
{
   // All profiles without problems, but not start- or end-of-coast profiles
   if ((! m_bStartOfCoast) &&
       (! m_bEndOfCoast) &&
       (! m_bHitLand) &&
       (! m_bHitIntervention) &&
       (! m_bHitCoast) &&
       (! m_bTooShort) &&
       (! m_bTruncatedSameCoast) &&
       (! m_bHitAnotherProfile) &&
       (! m_bCShoreProblem))
      return true;
 
   return false;
}

bool CGeomProfile::bProfileOKIncTruncated(void) const
{
   // All profiles without problems, but not start- or end-of-coast profiles
   if ((! m_bStartOfCoast) &&
       (! m_bEndOfCoast) &&
       (! m_bHitLand) &&
       (! m_bHitIntervention) &&
       (! m_bHitCoast) &&
       (! m_bTooShort) &&
       (! m_bHitAnotherProfile) &&
       (! m_bCShoreProblem))
      return true;
 
   return false;
}

bool CGeomProfile::bOKIncStartAndEndOfCoast(void) const
{
   // All profiles without problems, including start- and end-of-coast profiles
   if ((! m_bHitLand) &&
       (! m_bHitIntervention) &&
       (! m_bHitCoast) &&
       (! m_bTooShort) &&
       (! m_bTruncatedSameCoast) &&
       (! m_bHitAnotherProfile) &&
       (! m_bCShoreProblem))
      return true;
 
   return false;
}
 
// //! Returns true if this is a problem-free profile (however it could still be a start-of-coast profile)
// bool CGeomProfile::bOKIncStartOfCoast(void) const
// {
//    // All profiles without problems, including start-of-coast profile (but not end-of-coast profile)
// if ((! m_bEndOfCoast) &&
// (! m_bHitLand) &&
// (! m_bHitIntervention) &&
// (! m_bHitCoast) &&
// (! m_bTooShort) &&
// (! m_bTruncatedSameCoast) &&
// (! m_bHitAnotherProfile))
// return true;
//
// return false;
// }

void CGeomProfile::SetPointsInProfile(vector<CGeom2DPoint> const* VNewPoints)
{
   CGeomMultiLine::m_VPoints = *VNewPoints;
}

void CGeomProfile::SetPointInProfile(int const nPoint, double const dNewX, double const dNewY)
{
   // TODO 055 No check to see if nPoint < CGeomMultiLine::m_VPoints,size()
   CGeomMultiLine::m_VPoints[nPoint] = CGeom2DPoint(dNewX, dNewY);
}

void CGeomProfile::AppendPointInProfile(double const dNewX, double const dNewY)
{
   CGeomMultiLine::m_VPoints.push_back(CGeom2DPoint(dNewX, dNewY));
}

void CGeomProfile::AppendPointInProfile(CGeom2DPoint const* pPt)
{
   CGeomMultiLine::m_VPoints.push_back(*pPt);
}

bool CGeomProfile::bInsertIntersection(double const dX, double const dY, int const nSeg)
{
   // Safety check
   if (nSeg >= nGetNumLineSegments())
      return false;
 
   vector<CGeom2DPoint>::iterator it;
   it = CGeomMultiLine::m_VPoints.begin();
 
   // Do the insertion
   CGeomMultiLine::m_VPoints.insert(it + nSeg + 1, CGeom2DPoint(dX, dY));
 
   // Now insert a line segment in the associated multi-line, this will inherit the profile/line seg details from the preceding line segment
   CGeomMultiLine::InsertLineSegment(nSeg);
 
   return true;
}

void CGeomProfile::TruncateProfile(int const nSize)
{
   CGeomMultiLine::m_VPoints.resize(nSize);
}
 
// void CGeomProfile::TruncateAndSetPointInProfile(int const nPoint, double const dNewX, double const dNewY)
// {
// CGeomMultiLine::m_VPoints.resize(nPoint+1);
// CGeomMultiLine::m_VPoints[nPoint] = CGeom2DPoint(dNewX, dNewY);
// }
 
// void CGeomProfile::ShowProfile(void) const
// {
// for (int n = 0; n < CGeomMultiLine::m_VPoints.size(); n++)
// {
// cout << n << " [" << CGeomMultiLine::m_VPoints[n].dGetX() << "][" << CGeomMultiLine::m_VPoints[n].dGetY() << "]" << endl;
// }
// }

int CGeomProfile::nGetProfileSize(void) const
{
   return static_cast<int>(CGeomMultiLine::m_VPoints.size());
}

CGeom2DPoint* CGeomProfile::pPtGetPointInProfile(int const n)
{
   return &CGeomMultiLine::m_VPoints[n];
}

vector<CGeom2DPoint> CGeomProfile::PtVGetThisPointAndAllAfter(int const nStart)
{
   return vector<CGeom2DPoint>(CGeomMultiLine::m_VPoints.begin() + nStart, CGeomMultiLine::m_VPoints.end());
}

// void CGeomProfile::RemoveLineSegment(int const nPoint)
// {
// m_VPoints.erase(CGeomMultiLine::m_VPoints.begin() + nPoint);
// CGeomMultiLine::RemoveLineSegment(nPoint);
// }

bool CGeomProfile::bIsPointInProfile(double const dX, double const dY)
{
   CGeom2DPoint const Pt(dX, dY);
   auto it = find(CGeomMultiLine::m_VPoints.begin(), CGeomMultiLine::m_VPoints.end(), &Pt);
 
   if (it != CGeomMultiLine::m_VPoints.end())
      return true;
   else
      return false;
}

bool CGeomProfile::bIsPointInProfile(double const dX, double const dY, int& nPoint)
{
   CGeom2DPoint const Pt(dX, dY);
   auto it = find(CGeomMultiLine::m_VPoints.begin(), CGeomMultiLine::m_VPoints.end(), &Pt);
 
   if (it != CGeomMultiLine::m_VPoints.end())
   {
      // Found, so return true and set nPoint to be the index of the point which was found
      nPoint = static_cast<int>(it - CGeomMultiLine::m_VPoints.begin());
      return true;
   }
 
   else
      return false;
}
 
// int CGeomProfile::nFindInsertionLineSeg(double const dInsertX, double const dInsertY)
// {
// for (int n = 0; n < CGeomMultiLine::m_VPoints.back(); n++)
// {
// double
// dThisX = CGeomMultiLine::m_VPoints[n].dGetX(),
// dThisY = CGeomMultiLine::m_VPoints[n].dGetY(),
// dNextX = CGeomMultiLine::m_VPoints[n+1].dGetX(),
// dNextY = CGeomMultiLine::m_VPoints[n+1].dGetY();
//
// bool
// bBetweenX = false,
// bBetweenY = false;
//
// if (dNextX >= dThisX)
// {
//          // Ascending
// if ((dInsertX >= dThisX) && (dInsertX <= dNextX))
// bBetweenX = true;
// }
// else
// {
//          // Descending
// if ((dInsertX >= dNextX) && (dInsertX <= dThisX))
// bBetweenX = true;
// }
//
// if (dNextY >= dThisY)
// {
//          // Ascending
// if ((dInsertY >= dThisY) && (dInsertY <= dNextY))
// bBetweenY = true;
// }
// else
// {
//          // Descending
// if ((dInsertY >= dNextY) && (dInsertY <= dThisY))
// bBetweenY = true;
// }
//
// if (bBetweenX && bBetweenY)
// return n;
// }
//
// return -1;
// }
 
// void CGeomProfile::AppendPointShared(bool const bShared)
// {
// m_bVShared.push_back(bShared);
// }
 
// bool CGeomProfile::bPointShared(int const n) const
// {
//    // TODO 055 No check to see if n < size()
// return m_bVShared[n];
// }

void CGeomProfile::SetUpCoastAdjacentProfile(CGeomProfile* pProfile)
{
   m_pUpCoastAdjacentProfile = pProfile;
}
 
// //! Returns the up-coast adjacent profile, returns NULL if there is no up-coast adjacent profile
// CGeomProfile* CGeomProfile::pGetUpCoastAdjacentProfile(void) const
// {
//    return m_pUpCoastAdjacentProfile;
// }

void CGeomProfile::SetDownCoastAdjacentProfile(CGeomProfile* pProfile)
{
   m_pDownCoastAdjacentProfile = pProfile;
}

CGeomProfile* CGeomProfile::pGetDownCoastAdjacentProfile(void) const
{
   return m_pDownCoastAdjacentProfile;
}

void CGeomProfile::AppendCellInProfile(CGeom2DIPoint const* pPti)
{
   m_VCellInProfile.push_back(*pPti);
}

void CGeomProfile::AppendCellInProfile(int const nX, int const nY)
{
   m_VCellInProfile.push_back(CGeom2DIPoint(nX, nY));
}

void CGeomProfile::SetCellsInProfile(vector<CGeom2DIPoint> const* VNewPoints)
{
   m_VCellInProfile = *VNewPoints;
}

vector<CGeom2DIPoint>* CGeomProfile::pPtiVGetCellsInProfile(void)
{
   return &m_VCellInProfile;
}

CGeom2DIPoint* CGeomProfile::pPtiGetCellInProfile(int const n)
{
   // TODO 055 No check to see if n < size()
   return &m_VCellInProfile[n];
}

CGeom2DIPoint* CGeomProfile::pPtiGetLastCellInProfile(void)
{
   // In grid CRS
   return &m_VCellInProfile.back();
}

CGeom2DIPoint* CGeomProfile::pPtiGetFirstCellInProfile(void)
{
   // In grid CRS
   return &m_VCellInProfile.front();
}

int CGeomProfile::nGetNumCellsInProfile(void) const
{
   return static_cast<int>(m_VCellInProfile.size());
}

int CGeomProfile::nGetCellGivenDepth(CGeomRasterGrid const* pGrid, double const dDepthIn)
{
   int nIndex = INT_NODATA; // If not found, i.e. if every profile cell has sea depth less than dDepthIn
 
   for (unsigned int n = 0; n < m_VCellInProfile.size(); n++)
   {
      int const nX = m_VCellInProfile[n].nGetX();
      int const nY = m_VCellInProfile[n].nGetY();
 
      double const dCellDepth = pGrid->m_Cell[nX][nY].dGetSeaDepth();
 
      if (dCellDepth >= dDepthIn)
      {
         nIndex = n;
 
         if (n > 0)
            nIndex = n - 1; // Grid CRS units
 
         break;
      }
   }
 
   return nIndex;
}

void CGeomProfile::SetProfileDeepWaterWaveHeight(double const dWaveHeight)
{
   m_dDeepWaterWaveHeight = dWaveHeight;
}

double CGeomProfile::dGetProfileDeepWaterWaveHeight(void) const
{
   return m_dDeepWaterWaveHeight;
}

void CGeomProfile::SetProfileDeepWaterWaveAngle(double const dWaveAngle)
{
   m_dDeepWaterWaveAngle = dWaveAngle;
}

double CGeomProfile::dGetProfileDeepWaterWaveAngle(void) const
{
   return m_dDeepWaterWaveAngle;
}

void CGeomProfile::SetProfileDeepWaterWavePeriod(double const dWavePeriod)
{
   m_dDeepWaterWavePeriod = dWavePeriod;
}

double CGeomProfile::dGetProfileDeepWaterWavePeriod(void) const
{
   return m_dDeepWaterWavePeriod;
}

bool CGeomProfile::bIsIntervention(void) const
{
   return m_bIntervention;
}
 
// //! Returns the index of a given cell in the vector of profile cells; returns INT_NODATA if not found
// int CGeomProfile::nGetIndexOfCellInProfile(int const nX, int const nY)
// {
//    for (unsigned int n = 0; n < m_VCellInProfile.size(); n++)
//    {
//       if ((m_VCellInProfile[n].nGetX() == nX) && (m_VCellInProfile[n].nGetY() == nY))
//          return n;
//    }
//
//    return INT_NODATA;
// }