PathMapTile.h

Go to the documentation of this file.

 
#ifndef IMPBFF_PATHMAPTILE_H
#define IMPBFF_PATHMAPTILE_H
 
#include <IMP/bff/bff_config.h>
 
#include <cmath>  /* std::sqrt */
#include <vector>
#include <utility> /* std::pair */
#include <algorithm>
 
#include <IMP/bff/PathMap.h>
#include <IMP/bff/PathMapTileEdge.h>
 
IMPBFF_BEGIN_NAMESPACE
 
const bool  TILE_VISITED_DEFAULT    = false;
const float TILE_PENALTY_DEFAULT    = 100000.0f;
const float TILE_COST_DEFAULT       = 100000.0f;
const float TILE_EDGE_COST_DEFAULT  = 100000.0f;
 
const float TILE_PENALTY_THRESHOLD  = 100000.0f;
const float TILE_OBSTACLE_THRESHOLD = 0.000001f;
const float TILE_OBSTACLE_PENALTY   = 100000.0f;
 
 
typedef enum{
    PM_TILE_PENALTY,             
    PM_TILE_COST,                
    PM_TILE_DENSITY,             
    PM_TILE_COST_DENSITY,        
    PM_TILE_PATH_LENGTH,         
    PM_TILE_PATH_LENGTH_DENSITY, 
    PM_TILE_FEATURE,             
    PM_TILE_ACCESSIBLE_DENSITY,  
    PM_TILE_ACCESSIBLE_FEATURE   
} PathMapTileOutputs;
 
 
class PathMap;
 
class IMPBFFEXPORT PathMapTile{
 
friend class PathMap;
 
private:
 
 
    void update_edges(
            IMP::bff::PathMap* av,
            std::vector<PathMapTile> &tiles,
            double neighbor_radius,
            float tile_penalty_threshold = TILE_PENALTY_THRESHOLD
    );
 
    void update_edges_2(
            int nx, int ny, int nz,
            std::vector<PathMapTile>& tiles,
            std::vector<int> neighbor_idxs,
            float tile_penalty_threshold =TILE_PENALTY_THRESHOLD
    );
 
 
protected:
 
    long idx;                  // tile index: corresponds to voxel index
 
    // Variable for path search
    float penalty;                  // penalty for visiting tile in a path search
    float cost;                     // total cost for visiting tile in a path search (integrated cost)
    PathMapTile* previous; // tile previously visited in path search
 
    // Additional tile feature (e.g. av density)
    std::map<std::string, float> features;
 
    // Edges leaving tile and going to neighboring tiles
    std::vector<PathMapTileEdge> edges;
 
public:
 
    float density;
 
 
    explicit PathMapTile(
            long index=-1,
            float visit_penalty = 0.0,
            float tile_density = 1.0
    ) :
            idx(index),
            penalty(visit_penalty),
            cost(std::numeric_limits<float>::max()),
            previous(nullptr),
            density(tile_density)
    {}
 
 
    std::vector<long> backtrack_to_path();
 
    float get_value(
            int value_type,
            std::pair<float, float> bounds = std::pair<float, float>(
                            {std::numeric_limits<float>::min(),
                             std::numeric_limits<float>::max()}),
            const std::string &feature_name="",
            float grid_spacing = 1.0
    );
 
 
    void set_value(int value_type, float value, const std::string &name="");
 
};
 
 
IMPBFF_END_NAMESPACE
 
#endif //IMPBFF_PATHMAPTILE_H