#if 0

unit_convert( double( lp->feature->distlabel ),

pal::PIXEL,

pal->map_unit,

pal->dpi, scale, 1 );

#endif

#include "simplemutex.h"

// uncomment for Wolff 2 position model test on RailwayStation

//if (nbp==2)

// beta = M_PI/2;

#if 0

double distlabel = unit_convert( this->distlabel,

pal::PIXEL,

layer->pal->map_unit,

dpi, scale, delta_width );

#endif

#if 0

double distlabel = unit_convert( this->distlabel,

pal::PIXEL,

layer->pal->map_unit,

dpi, scale, delta_width );

#endif

#if 0

/**

* \brief Feature against problem bbox

* \param bbox[0] problem x min

* \param bbox[1] problem x max

* \param bbox[2] problem y min

* \param bbox[3] problem y max

* return A set of feature which are in the bbox or null if the feature is in the bbox

*/

LinkedList<Feature*> *splitFeature( double bbox[4] );

/**

* \brief return the feature id

* \return the feature id

*/

int getId();

#endif

#if 0

/**

* \brief save the feature into file

* Called by Pal::save()

* \param file the file to write

*/

void save( std::ofstream *file );

#endif

#if 0

double PointSet::getDistInside( double px, double py )

{

double dist[8];

double rpx[8];

double rpy[8];

bool ok[8];

if ( !isPointInPolygon( nbPoints, x, y, px, py ) )

{

double d = getDist( px, py );

//std::cout << "Outside : " << d << std::endl;

if ( d < 0 )

{

d = -( d * d * d * d );

}

else

{

d = d * d * d * d;

}

return d;

}

int i;

double width = ( xmax - xmin ) * 2;

double height = ( ymax - ymin ) * 2;

/*

1 0 7

\ | /

2 --x -- 6

/ | \

3 4 5

*/

// Compute references points

for ( i = 0; i < 8; i++ )

{

dist[i] = DBL_MAX;

ok[i] = false;

rpx[i] = px;

rpy[i] = py;

}

rpx[0] += 0;

rpy[0] += height;

rpx[1] -= width;

rpy[1] += height;

rpx[2] -= width;

rpy[2] += 0;

rpx[3] -= width;

rpy[3] -= height;

rpx[4] += 0;

rpy[4] -= height;

rpx[5] += width;

rpy[5] -= height;

rpx[6] += width;

rpy[6] += 0;

rpx[7] += width;

rpy[7] += height;

int j, k;

for ( i = 0; i < nbPoints; i++ )

{

j = ( i + 1 ) % nbPoints;

for ( k = 0; k < 8; k++ )

{

double ix, iy;

if ( computeSegIntersection( px, py, rpx[k], rpy[k], x[i], y[i], x[j], y[j], &ix, &iy ) )

{

double d = dist_euc2d_sq( px, py, ix, iy );

if ( dist[k] > d )

{

dist[k] = d;

ok[k] = true;

//std::cout << "new dist for " << k << ": " << dist[k] << std::endl;

}

}

}

}

double a, b, c, d;

for ( i = 0; i < 8; i++ )

{

if ( !ok[i] )

{

std::cout << "ERROR!!!!!!!!!!!!!!!!!" << std::endl;

dist[i] = 0;

}

//std::cout << "dist[" << i << "]: " << dist[i] << std::endl;

}

a = min( dist[0], dist[4] );

b = min( dist[1], dist[5] );

c = min( dist[2], dist[6] );

d = min( dist[3], dist[7] );

/*

std::cout << "a: " << a << std::endl;

std::cout << "b: " << b << std::endl;

std::cout << "c: " << c << std::endl;

std::cout << "d: " << d << std::endl;

*/

//a = (a+b+c+d)/4.0;

//a = min(a,b);

//c = min(c,d);

//return min(a,c);

return ( a*b*c*d );

}

#endif