38 #ifndef LIBAVOID_VPSC_H 39 #define LIBAVOID_VPSC_H 53 #include "libvpsc/variable.h" 54 #include "libvpsc/constraint.h" 55 #include "libvpsc/rectangle.h" 56 #include "libvpsc/solve_VPSC.h" 64 using vpsc::delete_object;
75 #include "libavoid/assertions.h" 84 class CompareConstraints {
86 bool operator() (Constraint *
const &l, Constraint *
const &r)
const;
88 struct PositionStats {
89 PositionStats() : scale(0), AB(0), AD(0), A2(0) {}
90 void addVariable(Variable*
const v);
97 typedef std::priority_queue<Constraint*,std::vector<Constraint*>,
98 CompareConstraints> Heap;
102 typedef Variables::iterator Vit;
103 typedef Constraints::iterator Cit;
104 typedef Constraints::const_iterator Cit_const;
106 friend std::ostream& operator <<(std::ostream &os,
const Block &b);
113 Block(Blocks *blocks, Variable*
const v=
nullptr);
115 Constraint* findMinLM();
116 Constraint* findMinLMBetween(Variable*
const lv, Variable*
const rv);
117 Constraint* findMinInConstraint();
118 Constraint* findMinOutConstraint();
119 void deleteMinInConstraint();
120 void deleteMinOutConstraint();
121 void updateWeightedPosition();
122 void merge(Block *b, Constraint *c,
double dist);
123 Block* merge(Block *b, Constraint *c);
124 void mergeIn(Block *b);
125 void mergeOut(Block *b);
126 void split(Block *&l, Block *&r, Constraint *c);
127 Constraint* splitBetween(Variable* vl, Variable* vr, Block* &lb, Block* &rb);
128 void setUpInConstraints();
129 void setUpOutConstraints();
135 bool getActivePathBetween(Constraints& path, Variable
const* u,
136 Variable
const* v, Variable
const *w)
const;
137 bool isActiveDirectedPathBetween(
138 Variable
const* u, Variable
const* v)
const;
139 bool getActiveDirectedPathBetween(Constraints& path, Variable
const * u, Variable
const * v)
const;
141 typedef enum {
NONE, LEFT,
RIGHT} Direction;
142 typedef std::pair<double, Constraint*> Pair;
143 void reset_active_lm(Variable*
const v, Variable*
const u);
144 void list_active(Variable*
const v, Variable*
const u);
145 double compute_dfdv(Variable*
const v, Variable*
const u);
146 double compute_dfdv(Variable*
const v, Variable*
const u, Constraint *&min_lm);
147 bool split_path(Variable*, Variable*
const, Variable*
const,
148 Constraint* &min_lm,
bool desperation);
149 bool canFollowLeft(Constraint
const* c, Variable
const* last)
const;
150 bool canFollowRight(Constraint
const* c, Variable
const* last)
const;
151 void populateSplitBlock(Block *b, Variable* v, Variable
const* u);
152 void addVariable(Variable* v);
153 void setUpConstraintHeap(Heap* &h,
bool in);
164 friend std::ostream& operator <<(std::ostream &os,
const Variable &v);
166 friend class Constraint;
167 friend class IncSolver;
170 double desiredPosition;
171 double finalPosition;
178 bool fixedDesiredPosition;
181 inline Variable(
const int id,
const double desiredPos=-1.0,
182 const double weight=1.0,
const double scale=1.0)
184 , desiredPosition(desiredPos)
190 , fixedDesiredPosition(false)
193 double dfdv(
void)
const {
194 return 2. * weight * ( position() - desiredPosition );
197 inline double position(
void)
const {
198 return (block->ps.scale*block->posn+offset)/scale;
200 inline double unscaledPosition(
void)
const {
201 COLA_ASSERT(block->ps.scale == 1);
202 COLA_ASSERT(scale == 1);
203 return block->posn + offset;
211 Constraint(Variable *left, Variable *right,
double gap,
bool equality=
false);
213 inline double slack(
void)
const 221 return right->scale * right->position() - gap -
222 left->scale * left->position();
224 COLA_ASSERT(left->scale == 1);
225 COLA_ASSERT(right->scale == 1);
226 return right->unscaledPosition() - gap - left->unscaledPosition();
228 std::string toString(
void)
const;
230 friend std::ostream& operator <<(std::ostream &os,
const Constraint &c);
250 Blocks(Variables
const &vs);
252 void mergeLeft(Block *r);
253 void mergeRight(Block *l);
254 void split(Block *b, Block *&l, Block *&r, Constraint *c);
255 std::list<Variable*> *totalOrder();
260 Block *at(
size_t index)
const;
261 void insert(Block *block);
265 void dfsVisit(Variable *v, std::list<Variable*> *order);
266 void removeBlock(Block *doomed);
268 std::vector<Block *> m_blocks;
273 inline size_t Blocks::size()
const 275 return m_blocks.size();
278 inline Block *Blocks::at(
size_t index)
const 280 return m_blocks[index];
283 inline void Blocks::insert(Block *block)
285 m_blocks.push_back(block);
288 struct UnsatisfiableException {
291 struct UnsatisfiedConstraint {
292 UnsatisfiedConstraint(Constraint& c):c(c) {}
305 IncSolver(Variables
const &vs, Constraints
const &cs);
308 void addConstraint(Constraint *constraint);
309 Variables const & getVariables() {
return vs; }
321 bool constraintGraphIsCyclic(
const unsigned n, Variable*
const vs[]);
322 bool blockGraphIsCyclic();
325 Constraint* mostViolated(Constraints &l);
330 template <
typename T>
331 void operator()(T *ptr){
delete ptr;}
335 Variables
const &vars, Constraints
const &constraints);
339 #endif // ! USELIBVPSC 341 #endif // AVOID_VPSC_H A variable is comprised of an ideal position, final position and a weight.
Definition: variable.h:44
Incremental solver for Variable Placement with Separation Constraints problem instance.
Definition: solve_VPSC.h:105
ProjectionResult solve(vpsc::Variables &vs, vpsc::Constraints &cs, vpsc::Rectangles &rs, unsigned debugLevel=0)
Constructs a solver and attempts to solve the passed constraints on the passed vars.
std::vector< Variable * > Variables
A vector of pointers to Variable objects.
Definition: constraint.h:38
std::vector< Constraint * > Constraints
A vector of pointers to Constraint objects.
Definition: constraint.h:125
Constraints constraintsRemovingRedundantEqualities(const Variables &vars, const Constraints &constraints)
Given a set of variables and constraints, returns a modified set of constraints with all redundant eq...
Definition: constraint.cpp:188
A constraint determines a minimum or exact spacing required between two Variable objects.
Definition: constraint.h:44
Lateral constraints imply only a separation:
libavoid: Object-avoiding orthogonal and polyline connector routing library.
Definition: actioninfo.cpp:33