// ---------------------------------------------------------------------------
// CGpxConverterAO::CalculateBoundaries
// Calculate min and max coordinates for tracklog
// ---------------------------------------------------------------------------
void CGpxConverterAO::CalculateBoundaries()
{
LOG("CGpxConverterAO::CalculateBoundaries start");
const TInt KMaxLat = 90;
const TInt KMinLat = -90;
const TInt KMaxLon = 180;
const TInt KMinLon = -180;
if ( !iBoundaries )
{
iBoundaries = new TBoundaries;
iBoundaries->minLatitude = KMaxLat;
iBoundaries->maxLatitude = KMinLat;
iBoundaries->minLongitude = KMaxLon;
iBoundaries->maxLongitude = KMinLon;
iBoundaries->distance = 0;
}
if( !Math::IsNaN( iTempItem.iLatitude ) && !Math::IsNaN( iTempItem.iLongitude ))
{
TReal32 distance;
if ( !iLastCoords )
{
iLastCoords = new TCoordinate( iTempItem.iLatitude, iTempItem.iLongitude );
}
else
{
TCoordinate tempCoord( iTempItem.iLatitude, iTempItem.iLongitude );
TLocality newCoords( tempCoord, iTempItem.iHdop );
TInt err = newCoords.Distance(*iLastCoords, distance);
if ( err == KErrNone )
{
delete iLastCoords;
iLastCoords = new TCoordinate( tempCoord );
iBoundaries->distance += distance;
}
}
iBoundaries->maxLatitude = Max( iBoundaries->maxLatitude, iTempItem.iLatitude );
iBoundaries->minLatitude = Min( iBoundaries->minLatitude, iTempItem.iLatitude );
iBoundaries->maxLongitude = Max( iBoundaries->maxLongitude, iTempItem.iLongitude );
iBoundaries->minLongitude = Min( iBoundaries->minLongitude, iTempItem.iLongitude );
}
LOG("CGpxConverterAO::CalculateBoundaries end");
}
void MyFRPROptimizer::StartOptimization() {
unsigned int i;
if (m_CostFunction.IsNull()) {
return;
}
this->InvokeEvent(StartEvent());
this->SetStop(false);
this->SetSpaceDimension(m_CostFunction->GetNumberOfParameters());
MyFRPROptimizer::ParametersType tempCoord(this->GetSpaceDimension());
double gg, gam, dgg;
MyFRPROptimizer::ParametersType g(this->GetSpaceDimension());
MyFRPROptimizer::ParametersType h(this->GetSpaceDimension());
MyFRPROptimizer::ParametersType xi(this->GetSpaceDimension());
MyFRPROptimizer::ParametersType p(this->GetSpaceDimension());
p = this->GetInitialPosition();
this->SetCurrentPosition(p);
double fp;
this->GetValueAndDerivative(p, &fp, &xi);
// cout << "Gradient: " << xi << endl;
for (i = 0; i < this->GetSpaceDimension(); i++) {
g[i] = -xi[i];
xi[i] = g[i];
h[i] = g[i];
}
unsigned int limitCount = 0;
for (unsigned int currentIteration = 0;
currentIteration <= this->GetMaximumIteration();
currentIteration++) {
this->SetCurrentIteration(currentIteration);
double fret;
fret = fp;
this->LineOptimize(&p, xi, &fret, tempCoord);
double delta = 2.0 * vcl_abs(fret - fp);
double tolerance = this->GetValueTolerance() * (vcl_abs(fret) + vcl_abs(fp) + FRPR_TINY);
// cout << "Line Optimization: " << tempCoord << "; delta: " << delta << "; tolerance: " << tolerance << endl;
if (delta <= tolerance) {
if (limitCount < this->GetSpaceDimension()) {
this->GetValueAndDerivative(p, &fp, &xi);
xi[limitCount] = 1;
limitCount++;
} else {
this->SetCurrentPosition(p);
this->InvokeEvent( EndEvent() );
return;
}
} else {
limitCount = 0;
this->GetValueAndDerivative(p, &fp, &xi);
}
gg = 0.0;
dgg = 0.0;
if (m_OptimizationType == PolakRibiere) {
for (i = 0; i < this->GetSpaceDimension(); i++) {
gg += g[i] * g[i];
dgg += (xi[i] + g[i]) * xi[i];
}
}
if (m_OptimizationType == FletchReeves) {
for (i = 0; i < this->GetSpaceDimension(); i++) {
gg += g[i] * g[i];
dgg += xi[i] * xi[i];
}
}
cout << "Terminal Criterion: " << abs(gg) << endl;
if (abs(gg) < 1e-5) {
this->SetCurrentPosition(p);
this->InvokeEvent(EndEvent());
return;
}
gam = dgg / gg;
// cout << "DGG: " << dgg << ", GG: " << gg << ", gam: " << gam << endl;
for (i = 0; i < this->GetSpaceDimension(); i++) {
g[i] = -xi[i];
xi[i] = g[i] + gam * h[i];
h[i] = xi[i];
}
this->SetCurrentPosition(p);
this->InvokeEvent(IterationEvent());
}
this->InvokeEvent(EndEvent());
}
void MyFRPROptimizer::LineOptimize(ParametersType *p, ParametersType & xi,
double *val) {
ParametersType tempCoord(this->GetSpaceDimension());
this->LineOptimize(p, xi, val, tempCoord);
}
void WHtreeProcesser::coarseTree( const unsigned int coarseRatio )
{
if( coarseRatio < 2 )
{
return;
}
std::map< WHcoord, size_t > roimap;
size_t count( 0 );
//create a matrix with seed voxels positions
std::vector< std::vector< std::vector< bool > > > roimatrix;
roimatrix.resize( m_tree.m_datasetSize.m_x );
for( size_t i = 0; i < roimatrix.size(); ++i )
{
roimatrix[i].resize( m_tree.m_datasetSize.m_y );
for( size_t j = 0; j < roimatrix[i].size(); ++j )
{
roimatrix[i][j].resize( m_tree.m_datasetSize.m_z, false );
}
}
for( std::vector< WHcoord >::const_iterator coordIter = m_tree.m_coordinates.begin(); coordIter != m_tree.m_coordinates.end(); ++coordIter )
{
//std::cout <<*coord_iter<< std::endl;
roimatrix[coordIter->m_x][coordIter->m_y][coordIter->m_z] = true;
roimap.insert( std::make_pair( *coordIter, count++ ) );
}
// convert previously discarded elements to new grid
std::list< WHcoord > newDiscarded( m_tree.m_discarded );
for( std::list< WHcoord >::iterator iter( newDiscarded.begin() ); iter != newDiscarded.end(); ++iter )
{
iter->m_x = iter->m_x / coarseRatio;
iter->m_y = iter->m_y / coarseRatio;
iter->m_z = iter->m_z / coarseRatio;
}
newDiscarded.sort();
newDiscarded.unique();
WHcoord newDataSetSize( m_tree.m_datasetSize.m_x / coarseRatio, m_tree.m_datasetSize.m_y / coarseRatio,
m_tree.m_datasetSize.m_z / coarseRatio );
//loop through coarser grid
for( coord_t k = 0; k < m_tree.m_datasetSize.m_z; k += coarseRatio )
{
for( coord_t j = 0; j < m_tree.m_datasetSize.m_y; j += coarseRatio )
{
for( coord_t i = 0; i < m_tree.m_datasetSize.m_x; i += coarseRatio )
{
//loop through finer grid
std::list< WHcoord > bigGridVoxel;
for( unsigned int n = 0; n < coarseRatio; ++n )
{
for( unsigned int m = 0; m < coarseRatio; ++m )
{
for( unsigned int l = 0; l < coarseRatio; ++l )
{
if( roimatrix[i + l][j + m][k + n] )
{
WHcoord tempCoord( i + l, j + m, k + n );
bigGridVoxel.push_back( tempCoord );
}
}
}
}
if( !bigGridVoxel.empty() )
{
WHcoord keptCoord( bigGridVoxel.front() );
bigGridVoxel.pop_front();
size_t keptID( roimap[keptCoord] );
WHcoord newCoord( keptCoord.m_x / coarseRatio, keptCoord.m_y / coarseRatio, keptCoord.m_z / coarseRatio );
m_tree.m_coordinates[keptID] = newCoord;
for( std::list< WHcoord >::iterator iter( bigGridVoxel.begin() ); iter != bigGridVoxel.end(); ++iter )
{
size_t decimatedID( roimap[*iter] );
m_tree.fetchLeaf( decimatedID )->setFlag( true );
WHcoord emptyCoord;
m_tree.m_coordinates[decimatedID] = emptyCoord;
}
}
}
}
}
m_tree.cleanup();
m_tree.debinarize();
m_tree.m_discarded = newDiscarded;
m_tree.m_datasetSize = newDataSetSize;
m_tree.m_treeName += ( "_coarse" + string_utils::toString( coarseRatio ) );
return;
} // end "coarseTree()" -----------------------------------------------------------------
