src/libvpsc/csolve_VPSC.cpp

   1 /**
   2  * \brief Bridge for C programs to access solve_VPSC (which is in C++)
   3  *
   4  * Authors:
   5  *   Tim Dwyer <tgdwyer@gmail.com>
   6  *
   7  * Copyright (C) 2005 Authors
   8  *
   9  * Released under GNU LGPL.  Read the file 'COPYING' for more information.
  10  */
  11 #include <iostream>
  12 #include <cassert>
  13 #include <cstdlib>
  14 #include "variable.h"
  15 #include "constraint.h"
  16 #include "generate-constraints.h"
  17 #include "solve_VPSC.h"
  18 #include "csolve_VPSC.h"
  19 using namespace vpsc;
  20 extern "C" {
  21 Variable* newVariable(int id, double desiredPos, double weight) {
  22         return new Variable(id,desiredPos,weight);
  23 }
  24 Constraint* newConstraint(Variable* left, Variable* right, double gap) {
  25         return new Constraint(left,right,gap);
  26 }
  27 Solver* newSolver(int n, Variable* vs[], int m, Constraint* cs[]) {
  28         return new Solver(n,vs,m,cs);
  29 }
  30 Solver* newIncSolver(int n, Variable* vs[], int m, Constraint* cs[]) {
  31         return (Solver*)new vpsc::IncSolver(n,vs,m,cs);
  32 }
  33
  34 int genXConstraints(int n, boxf* bb, Variable** vs, Constraint*** cs,int transitiveClosure) {
  35         Rectangle* rs[n];
  36         for(int i=0;i<n;i++) {
  37                 rs[i]=new Rectangle(bb[i].LL.x,bb[i].UR.x,bb[i].LL.y,bb[i].UR.y);
  38         }
  39         int m = generateXConstraints(n,rs,vs,*cs,transitiveClosure);
  40         for(int i=0;i<n;i++) {
  41                 delete rs[i];
  42         }
  43         return m;
  44 }
  45 int genYConstraints(int n, boxf* bb, Variable** vs, Constraint*** cs) {
  46         Rectangle* rs[n];
  47         for(int i=0;i<n;i++) {
  48                 rs[i]=new Rectangle(bb[i].LL.x,bb[i].UR.x,bb[i].LL.y,bb[i].UR.y);
  49         }
  50         int m = generateYConstraints(n,rs,vs,*cs);
  51         for(int i=0;i<n;i++) {
  52                 delete rs[i];
  53         }
  54         return m;
  55 }
  56
  57 Constraint** newConstraints(int m) {
  58         return new Constraint*[m];
  59 }
  60 void deleteConstraints(int m, Constraint **cs) {
  61         for(int i=0;i<m;i++) {
  62                 delete cs[i];
  63         }
  64         delete [] cs;
  65 }
  66 void deleteConstraint(Constraint* c) {
  67         delete c;
  68 }
  69 void deleteVariable(Variable* v) {
  70         delete v;
  71 }
  72 void satisfyVPSC(Solver* vpsc) {
  73         try {
  74                 vpsc->satisfy();
  75         } catch(const char *e) {
  76                 std::cerr << e << std::endl;
  77                 exit(1);
  78         }
  79 }
  80 int getSplitCnt(IncSolver *vpsc) {
  81         return vpsc->splitCnt;
  82 }
  83 void deleteVPSC(Solver *vpsc) {
  84         assert(vpsc!=NULL);
  85         delete vpsc;
  86 }
  87 void solveVPSC(Solver* vpsc) {
  88         vpsc->solve();
  89 }
  90 void splitIncVPSC(IncSolver* vpsc) {
  91         vpsc->splitBlocks();
  92 }
  93 void setVariableDesiredPos(Variable *v, double desiredPos) {
  94         v->desiredPosition = desiredPos;
  95 }
  96 double getVariablePos(Variable *v) {
  97         return v->position();
  98 }
  99 void remapInConstraints(Variable *u, Variable *v, double dgap) {
 100         for(Constraints::iterator i=u->in.begin();i!=u->in.end();i++) {
 101                 Constraint* c=*i;
 102                 c->right=v;
 103                 c->gap+=dgap;
 104                 v->in.push_back(c);
 105         }
 106         u->in.clear();
 107 }
 108 void remapOutConstraints(Variable *u, Variable *v, double dgap) {
 109         for(Constraints::iterator i=u->out.begin();i!=u->out.end();i++) {
 110                 Constraint* c=*i;
 111                 c->left=v;
 112                 c->gap+=dgap;
 113                 v->out.push_back(c);
 114         }
 115         u->out.clear();
 116 }
 117 int getLeftVarID(Constraint *c) {
 118         return c->left->id;
 119 }
 120 int getRightVarID(Constraint *c){
 121         return c->right->id;
 122 }
 123 double getSeparation(Constraint *c){
 124         return c->gap;
 125 }
 126 }