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