VC6 -> VC2005 conversion problem
- From: Philippe <pasdemail@xxxxx>
- Date: Fri, 11 Jan 2008 09:19:42 +0100
Hello,
I'm converting my project from VC++6 to VC++2005.
among many compilation errors now solved, that one is stucking me :
I have that template :
template <class T>
class TLineApproximator
{
public:
//! \name Structures and typedefs
//@{
//! 2D homogenous point
struct SHomog
{
public:
SHomog(T _x=0, T _y=0, T _w=1) { x=_x; y=_y; w=_w;};
T x;
T y;
T w;
};
//! 2D point
struct SPoint
{
public:
SPoint(T _x=0, T _y=0) { x=_x; y=_y;};
static void CrossProduct( const SPoint& p, const SPoint& q, SHomog& r)
{
r.w = p.x * q.y - p.y * q.x;
r.x = - q.y + p.y;
r.y = q.x - p.x;
};
static T DotProduct( const SPoint& p, const SHomog& q)
{
return q.w + p.x*q.x + p.y*q.y;
};
static T DotProduct( const SPoint& p, const SPoint& q)
{
return p.x*q.x + p.y*q.y;
};
static void LinComb( T a, const SPoint& p, T b, const SPoint& q, SPoint& r)
{
r.x = a * p.x + b * q.x;
r.y = a * p.y + b * q.y;
};
T x;
T y;
};
//! Internal limit structure
struct SLimits
{
T dMinX;
T dMaxX;
T dMinY;
T dMaxY;
T GetCenterX() { return (dMaxX+dMinX)/2.0;};
T GetCenterY() { return (dMaxX+dMinX)/2.0;};
T GetWidth() { return dMaxX-dMinX;};
T GetHeight() { return dMaxY-dMinY;};
};
//! points container
typedef typename std::vector<SPoint> PointContainer;
//! Key containers
typedef typename std::list<PointContainer> KeyContainer;
//@}
//! \name Constructor
//@{
TLineApproximator(): m_dTol(0), m_bNormalization(true)
{m_limits.dMinX=m_limits.dMinY=0;m_limits.dMaxX=m_limits.dMaxY=1;};
~TLineApproximator(){};
//@}
//! \name Point handling
//@{
//! returns number of points
UINT GetPointSize() const { return m_cPoints.size();};
//! sets the points as copy of the vectors
void SetPoints( const std::vector<T>& vX, const std::vector<T>& vY);
//! return vector of points
PointContainer& GetPoints() { return m_cPoints;};
//! return vector of points, const
const PointContainer& GetPoints() const { return m_cPoints;};
//@}
//! \name Key handling
//@{
//! returns number of keys
UINT GetKeySize() const { return m_cKeys.size();};
//! return keys
KeyContainer& GetKeys() { return m_cKeys;};
//! return keys, const
const KeyContainer& GetKeys() const { return m_cKeys;};
//! fill vectors with keys
void GetKeys( std::vector<T>& vX, std::vector<T>& vY);
//@}
//! \name Tolerance
//@{
//! sets the tolerance
void SetTol( double dTol) { m_dTol = __max( dTol, 0);};
//! return current tolerance
double GetTol() const { return m_dTol;};
//@}
//! \name Normalization
//@{
//! enabled, disable normalization
void SetNormalization( bool bEnabled = true) { m_bNormalization = true;};
//! returns true if normalizing
bool IsNormalization() const { return m_bNormalization;};
//@}
//! \name Simplification functions
//@{
//! Initialize simplification
void ClearKeys() { m_cKeys.clear();};
//! Compute the keys
void Simplify();
/*! Shrink to compression level
\param dScale scaling to apply [0...1]
\param dScaleTol [optional] tolerance with respect to dScale, default is 0.05
\param nMaxIter [optional] maximum number of iterations, default is 250
\return number of estimations
*/
UINT ShrinkNorm( double dScale, double dScaleTol = 0.05, UINT nMaxIter = 250);
/*! Shrink to a specified number of points
\param n desired number of points in the approximate curve
\param nTol [optional] tolerance with respect to n, default is 10
\param nMaxIter [optional] maximum number of iterations, default is 250
\return number of estimations
*/
UINT Shrink( UINT nDesiredPoints, UINT nTol = 10, UINT nMaxIter = 250);
//@}
//! \name Helper functions
//@{
//! compute the bounding box
void ComputeBoundingBox();
//! return the point bounding box
const SLimits& GetBoundingBox() const { return m_limits;};
/*! Point normalization
Let $(x_i,y_i)$, the original points and $(\hat x_x, \hat y_i)$ the normalized points:
\[
\hat x_i = \frac{x_i - \bar x]}{\max_i (x_i-x_j)}
\]
where $\bar x, \bar y$ denote respectively the mean value of the $x_i$ and $y_i$.
\sa DeNormalizePoints
*/
void NormalizePoints();
/*! \brief Roll back normalization
\sa NormalizePoints
*/
void DeNormalizePoints();
//@}
protected:
//! \name Virtual functions
//@{
virtual void ComputeKeys() { ClearKeys();};
//@}
private:
double m_dTol;
bool m_bNormalization;
PointContainer m_cPoints;
KeyContainer m_cKeys;
SLimits m_limits;
};
inside, you can see the SPoint structure and its x and y members.
the faulty code is :
void CPGLLine2DLOD::PlotLineStripGfx(gfxinterface::CGfxInterface& gfx)
{
const LODLine::KeyContainer& kc= m_hull.GetKeys();
LODLine::KeyContainer::const_iterator it;
UINT i;
double* pX=new double[kc.size()];
double* pY=new double[kc.size()];
for (it=kc.begin(), i=0; it!=kc.end();it++, i++)
{
// line (174) in error
pX[i] = (*it)->x;
// idem
pY[i] = (*it)->y;
}
}
I get that compilation error :
c:\program files\microsoft visual studio 2005\vc\pgl\pglline2dlod.cpp(174) : error C2819: type 'std::vector<_Ty>' does not have an overloaded member 'operator ->'
with
[
_Ty=hull::TLineApproximator<double>::SPoint
]
did you intend to use '.' instead?
c:\program files\microsoft visual studio 2005\vc\pgl\pglline2dlod.cpp(174) : error C2039: 'x' : is not a member of 'std::vector<_Ty>'
with
[
_Ty=hull::TLineApproximator<double>::SPoint
]
Strange, it compiled perfectly under VC6 and it's now faulty under VC2005
What norm change is responsible with that error and how to correct it ?
Any idea ?
Thanks in advance
Philippe
.
- Follow-Ups:
- Re: VC6 -> VC2005 conversion problem
- From: David Wilkinson
- Re: VC6 -> VC2005 conversion problem
- Prev by Date: Re: bool or BOOL in MFC projects
- Next by Date: Re: Common Controls and UNICODE support problem
- Previous by thread: Re: bool or BOOL in MFC projects
- Next by thread: Re: VC6 -> VC2005 conversion problem
- Index(es):
Relevant Pages
|
