1 /*****************************************************************************
2 ** This is part of the CTSim program
3 ** Copyright (c) 1983-2009 Kevin Rosenberg
5 ** This program is free software; you can redistribute it and/or modify
6 ** it under the terms of the GNU General Public License (version 2) as
7 ** published by the Free Software Foundation.
9 ** This program is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 ** GNU General Public License for more details.
14 ** You should have received a copy of the GNU General Public License
15 ** along with this program; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 ******************************************************************************/
20 class CubicSplineInterpolator {
22 double *m_pdY2; // second differential of y data
24 const double* const m_pdY;
28 CubicSplineInterpolator (const double* const y, int n);
30 ~CubicSplineInterpolator ();
32 double interpolate (double x);
36 class CubicPolyInterpolator {
38 const double* const m_pdY;
42 CubicPolyInterpolator (const double* const y, int n);
44 ~CubicPolyInterpolator ();
46 double interpolate (double x);
51 class BilinearInterpolator {
58 BilinearInterpolator (T** ppMatrix, unsigned int nx, unsigned int ny)
59 : m_ppMatrix(ppMatrix), m_nx(nx), m_ny(ny)
62 T interpolate (double dXPos, double dYPos)
64 int iFloorX = static_cast<int>(floor(dXPos));
65 int iFloorY = static_cast<int>(floor (dYPos));
66 double dXFrac = dXPos - iFloorX;
67 double dYFrac = dYPos - iFloorY;
71 if (iFloorX < 0 || iFloorY < 0 || iFloorX > m_nx-1 || iFloorY > m_ny-1)
73 else if (iFloorX == m_nx - 1 && iFloorY == m_ny - 1)
74 result = static_cast<T>(m_ppMatrix[m_nx-1][m_ny-1]);
75 else if (iFloorX == m_nx - 1)
76 result = static_cast<T>(m_ppMatrix[iFloorX][iFloorY] + dYFrac * (m_ppMatrix[iFloorX][iFloorY+1] - m_ppMatrix[iFloorX][iFloorY]));
77 else if (iFloorY == m_ny - 1)
78 result = static_cast<T>(m_ppMatrix[iFloorX][iFloorY] + dXFrac * (m_ppMatrix[iFloorX+1][iFloorY] - m_ppMatrix[iFloorX][iFloorY]));
80 result = static_cast<T>
81 ((1 - dXFrac) * (1 - dYFrac) * m_ppMatrix[iFloorX][iFloorY] +
82 dXFrac * (1 - dYFrac) * m_ppMatrix[iFloorX+1][iFloorY] +
83 dYFrac * (1 - dXFrac) * m_ppMatrix[iFloorX][iFloorY+1] +
84 dXFrac * dYFrac * m_ppMatrix[iFloorX+1][iFloorY+1]);
92 class BilinearPolarInterpolator {
100 BilinearPolarInterpolator (T** ppMatrix, unsigned int nAngle,
102 : m_ppMatrix(ppMatrix), m_nAngle(nAngle), m_nPos(nPos)
105 m_nCenterPos = (m_nPos - 1) / 2;
107 m_nCenterPos = m_nPos / 2;
110 T interpolate (double dAngle, double dPos)
112 int iFloorAngle = static_cast<int>(floor(dAngle));
113 int iFloorPos = static_cast<int>(floor (dPos));
114 double dAngleFrac = dAngle - iFloorAngle;
115 double dPosFrac = dPos - iFloorPos;
119 if (iFloorAngle < -1 || iFloorPos < 0 || iFloorAngle > m_nAngle-1 || iFloorPos > m_nPos-1)
121 else if (iFloorAngle == -1 && iFloorPos == m_nPos-1)
122 result = static_cast<T>(m_ppMatrix[0][m_nPos-1] + dAngleFrac * (m_ppMatrix[m_nAngle-1][iFloorPos] - m_ppMatrix[0][iFloorPos]));
123 else if (iFloorAngle == m_nAngle - 1 && iFloorPos == m_nPos-1)
124 result = static_cast<T>(m_ppMatrix[m_nAngle-1][m_nPos-1] + dAngleFrac * (m_ppMatrix[0][iFloorPos] - m_ppMatrix[m_nAngle-1][iFloorPos]));
125 else if (iFloorPos == m_nPos - 1)
126 result = static_cast<T>(m_ppMatrix[iFloorAngle][iFloorPos] + dAngleFrac * (m_ppMatrix[iFloorAngle+1][iFloorPos] - m_ppMatrix[iFloorAngle][iFloorPos]));
128 if (iFloorAngle == m_nAngle-1) {
130 int iLowerPos = (m_nPos-1) - iFloorPos;
131 int iUpperPos = (m_nPos-1) - (iFloorPos+1);
132 result = static_cast<T>
133 ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iFloorAngle][iFloorPos] +
134 dAngleFrac * (1-dPosFrac) * m_ppMatrix[iUpperAngle][iLowerPos] +
135 dPosFrac * (1-dAngleFrac) * m_ppMatrix[iFloorAngle][iFloorPos+1] +
136 dAngleFrac * dPosFrac * m_ppMatrix[iUpperAngle][iUpperPos]);
137 } else if (iFloorAngle == -1) {
138 int iLowerAngle = m_nAngle - 1;
139 int iLowerPos = (m_nPos-1) - iFloorPos;
140 int iUpperPos = (m_nPos-1) - (iFloorPos+1);
141 result = static_cast<T>
142 ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iLowerAngle][iLowerPos] +
143 dAngleFrac * (1-dPosFrac) * m_ppMatrix[iFloorAngle+1][iFloorPos] +
144 dPosFrac * (1-dAngleFrac) * m_ppMatrix[iLowerAngle][iUpperPos] +
145 dAngleFrac * dPosFrac * m_ppMatrix[iFloorAngle+1][iFloorPos+1]);
147 result = static_cast<T>
148 ((1-dAngleFrac) * (1-dPosFrac) * m_ppMatrix[iFloorAngle][iFloorPos] +
149 dAngleFrac * (1-dPosFrac) * m_ppMatrix[iFloorAngle+1][iFloorPos] +
150 dPosFrac * (1-dAngleFrac) * m_ppMatrix[iFloorAngle][iFloorPos+1] +
151 dAngleFrac * dPosFrac * m_ppMatrix[iFloorAngle+1][iFloorPos+1]);
159 class BicubicPolyInterpolator {
161 T** const m_ppMatrix;
162 const unsigned int m_nx;
163 const unsigned int m_ny;
166 BicubicPolyInterpolator (T** ppMatrix, unsigned int nx, unsigned int ny)
167 : m_ppMatrix(ppMatrix), m_nx(nx), m_ny(ny)
170 T interpolate (double dXPos, double dYPos)
172 // int iFloorX = static_cast<int>(floor (dXPos));
173 // int iFloorY = static_cast<int>(floor (dYPos));
174 // double dXFrac = dXPos - iFloorX;
175 // double dYFrac = dYPos - iFloorY;
187 class LinearInterpolator {
192 const bool m_bZeroOutsideRange;
195 LinearInterpolator (T* pY, unsigned int n, bool bZeroOutside = true)
196 : m_pX(0), m_pY(pY), m_n(n), m_bZeroOutsideRange(bZeroOutside)
199 LinearInterpolator (T* pX, T* pY, unsigned int n, bool bZeroOutside = true)
200 : m_pX(pX), m_pY(pY), m_n(n), m_bZeroOutsideRange(bZeroOutside)
203 double interpolate (double dX, int* piLastFloor = NULL)
211 if (m_bZeroOutsideRange)
215 } else if (dX == m_n - 1)
216 result = m_pY[m_n-1];
217 else if (dX > m_n - 1) {
218 if (m_bZeroOutsideRange)
221 result = m_pY[m_n - 1];
223 int iFloor = static_cast<int>(floor(dX));
224 result = m_pY[iFloor] + (m_pY[iFloor+1] - m_pY[iFloor]) * (dX - iFloor);
229 if (piLastFloor && *piLastFloor >= 0 && m_pX[*piLastFloor] < dX)
230 iLower = *piLastFloor;
232 while (iUpper - iLower > 1) {
233 int iMiddle = (iUpper + iLower) >> 1;
234 if (dX >= m_pX[iMiddle])
241 else if (dX < m_pX[0]) {
242 if (m_bZeroOutsideRange)
246 } else if (dX == m_pX[m_n-1])
247 result = m_pY[m_n-1];
248 else if (dX > m_pX[m_n - 1]) {
249 if (m_bZeroOutsideRange)
252 result = m_pY[m_n - 1];
254 if (iLower < 0 || iLower >= m_n) {
255 sys_error (ERR_SEVERE, "Coordinate out of range [linearInterpolate]");
260 *piLastFloor = iLower;
261 result = m_pY[iLower] + (m_pY[iUpper] - m_pY[iLower]) * ((dX - m_pX[iLower]) / (m_pX[iUpper] - m_pX[iLower]));