int main(void) {
Router *router = new Router(
PolyLineRouting | OrthogonalRouting);
router->setRoutingPenalty((PenaltyType)0, 50);
router->setRoutingPenalty((PenaltyType)1, 0);
router->setRoutingPenalty((PenaltyType)2, 50);
router->setRoutingPenalty((PenaltyType)3, 4000);
router->setRoutingPenalty((PenaltyType)4, 110);
router->setRoutingParameter(idealNudgingDistance, 25);
Polygon poly143407352(4);
poly143407352.ps[0] = Point(6035, 4390);
poly143407352.ps[1] = Point(6035, 5085);
poly143407352.ps[2] = Point(5675, 5085);
poly143407352.ps[3] = Point(5675, 4390);
new ShapeRef(router, poly143407352, 143407352);
Polygon poly124950386(4);
poly124950386.ps[0] = Point(4900, 4090);
poly124950386.ps[1] = Point(4900, 4785);
poly124950386.ps[2] = Point(4540, 4785);
poly124950386.ps[3] = Point(4540, 4090);
new ShapeRef(router, poly124950386, 124950386);
ConnRef *connRef373967044 = new ConnRef(router, 373967044);
ConnEnd srcPt373967044(Point(4890, 4250), 8);
connRef373967044->setSourceEndpoint(srcPt373967044);
ConnEnd dstPt373967044(Point(5685, 4550), 4);
connRef373967044->setDestEndpoint(dstPt373967044);
connRef373967044->setRoutingType((ConnType)2);
ConnRef *connRef681881486 = new ConnRef(router, 681881486);
ConnEnd srcPt681881486(Point(4890, 4325), 8);
connRef681881486->setSourceEndpoint(srcPt681881486);
ConnEnd dstPt681881486(Point(5685, 4625), 4);
connRef681881486->setDestEndpoint(dstPt681881486);
connRef681881486->setRoutingType((ConnType)2);
ConnRef *connRef829752 = new ConnRef(router, 829752);
ConnEnd srcPt829752(Point(4890, 4400), 8);
connRef829752->setSourceEndpoint(srcPt829752);
ConnEnd dstPt829752(Point(5685, 4700), 4);
connRef829752->setDestEndpoint(dstPt829752);
connRef829752->setRoutingType((ConnType)2);
ConnRef *connRef17625739 = new ConnRef(router, 17625739);
ConnEnd srcPt17625739(Point(4890, 4475), 8);
connRef17625739->setSourceEndpoint(srcPt17625739);
ConnEnd dstPt17625739(Point(5685, 4775), 4);
connRef17625739->setDestEndpoint(dstPt17625739);
connRef17625739->setRoutingType((ConnType)2);
ConnRef *connRef223864175 = new ConnRef(router, 223864175);
ConnEnd srcPt223864175(Point(4890, 4550), 8);
connRef223864175->setSourceEndpoint(srcPt223864175);
ConnEnd dstPt223864175(Point(5685, 4850), 4);
connRef223864175->setDestEndpoint(dstPt223864175);
connRef223864175->setRoutingType((ConnType)2);
ConnRef *connRef98144280 = new ConnRef(router, 98144280);
ConnEnd srcPt98144280(Point(4890, 4625), 8);
connRef98144280->setSourceEndpoint(srcPt98144280);
ConnEnd dstPt98144280(Point(5685, 4925), 4);
connRef98144280->setDestEndpoint(dstPt98144280);
connRef98144280->setRoutingType((ConnType)2);
ConnRef *connRef283100856 = new ConnRef(router, 283100856);
ConnEnd srcPt283100856(Point(4890, 4700), 8);
connRef283100856->setSourceEndpoint(srcPt283100856);
ConnEnd dstPt283100856(Point(5685, 5000), 4);
connRef283100856->setDestEndpoint(dstPt283100856);
connRef283100856->setRoutingType((ConnType)2);
ConnRef *connRef387080925 = new ConnRef(router, 387080925);
ConnEnd srcPt387080925(Point(5685, 4475), 4);
connRef387080925->setSourceEndpoint(srcPt387080925);
ConnEnd dstPt387080925(Point(4890, 4175), 8);
connRef387080925->setDestEndpoint(dstPt387080925);
connRef387080925->setRoutingType((ConnType)2);
router->processTransaction();
router->outputDiagram("output/orthordering-02");
int crossings = router->existsCrossings();
delete router;
return (crossings > 0) ? 1 : 0;
};
int main(void) {
Router *router = new Router(OrthogonalRouting);
router->setRoutingParameter((RoutingParameter)0, 50);
router->setRoutingParameter((RoutingParameter)1, 0);
router->setRoutingParameter((RoutingParameter)2, 0);
router->setRoutingParameter((RoutingParameter)3, 4000);
router->setRoutingParameter((RoutingParameter)4, 0);
router->setRoutingParameter((RoutingParameter)5, 100);
router->setRoutingParameter((RoutingParameter)6, 0);
router->setRoutingParameter((RoutingParameter)7, 4);
router->setRoutingOption((RoutingOption)0, true);
router->setRoutingOption((RoutingOption)1, true);
router->setRoutingOption((RoutingOption)2, false);
router->setRoutingOption((RoutingOption)3, false);
Polygon poly5(4);
poly5.ps[0] = Point(365.3425124847556, 152.0752314071785);
poly5.ps[1] = Point(365.3425124847556, 214.0752314071785);
poly5.ps[2] = Point(303.3425124847556, 214.0752314071785);
poly5.ps[3] = Point(303.3425124847556, 152.0752314071785);
new ShapeRef(router, poly5, 5);
Polygon poly7(4);
poly7.ps[0] = Point(365.3425124847556, 24.07523140617849);
poly7.ps[1] = Point(365.3425124847556, 86.07523140617849);
poly7.ps[2] = Point(303.3425124847556, 86.07523140617849);
poly7.ps[3] = Point(303.3425124847556, 24.07523140617849);
new ShapeRef(router, poly7, 7);
Polygon poly8(4);
poly8.ps[0] = Point(541.6758458190889, 24.07523140617849);
poly8.ps[1] = Point(541.6758458190889, 44.07523140617849);
poly8.ps[2] = Point(509.6758458190889, 44.07523140617849);
poly8.ps[3] = Point(509.6758458190889, 24.07523140617849);
new ShapeRef(router, poly8, 8);
Polygon poly10(4);
poly10.ps[0] = Point(541.6758458190889, 66.07523140617849);
poly10.ps[1] = Point(541.6758458190889, 86.07523140617849);
poly10.ps[2] = Point(509.6758458190889, 86.07523140617849);
poly10.ps[3] = Point(509.6758458190889, 66.07523140617849);
new ShapeRef(router, poly10, 10);
Polygon poly61(4);
poly61.ps[0] = Point(420.3425124847556, 101.0752314061785);
poly61.ps[1] = Point(420.3425124847556, 141.0752314061785);
poly61.ps[2] = Point(344.3425124847556, 141.0752314061785);
poly61.ps[3] = Point(344.3425124847556, 101.0752314061785);
new ShapeRef(router, poly61, 61);
Polygon poly92(4);
poly92.ps[0] = Point(563.5758458190888, 34.07523140617849);
poly92.ps[1] = Point(563.5758458190888, 76.07523140617849);
poly92.ps[2] = Point(487.7758458190889, 76.07523140617849);
poly92.ps[3] = Point(487.7758458190889, 34.07523140617849);
new ShapeRef(router, poly92, 92);
ConnRef *connRef109 = new ConnRef(router, 109);
ConnEnd srcPt109(Point(510.6758458190889, 34.07523140617849), 4);
connRef109->setSourceEndpoint(srcPt109);
ConnEnd dstPt109(Point(334.3425124847556, 183.0752314071785), 15);
connRef109->setDestEndpoint(dstPt109);
connRef109->setRoutingType((ConnType)2);
std::vector<Checkpoint> checkpoints109(1);
checkpoints109[0] = Checkpoint(Point(487.6758458190889, 55.07523140617849), (ConnDirFlags) 15, (ConnDirFlags) 4);
connRef109->setRoutingCheckpoints(checkpoints109);
ConnRef *connRef110 = new ConnRef(router, 110);
ConnEnd srcPt110(Point(510.6758458190889, 76.07523140617849), 4);
connRef110->setSourceEndpoint(srcPt110);
ConnEnd dstPt110(Point(334.3425124847556, 183.0752314071785), 15);
connRef110->setDestEndpoint(dstPt110);
connRef110->setRoutingType((ConnType)2);
std::vector<Checkpoint> checkpoints110(1);
checkpoints110[0] = Checkpoint(Point(487.6758458190889, 55.07523140617849), (ConnDirFlags) 15, (ConnDirFlags) 4);
connRef110->setRoutingCheckpoints(checkpoints110);
router->processTransaction();
router->outputDiagram("output/checkpoints02");
bool succeeded = true;
double checkpointY = 55.07523140617849;
Avoid::PolyLine route109 = connRef109->displayRoute();
if (fabs(route109.ps[route109.size() - 3].y - checkpointY) < 2)
{
succeeded = false;
}
Avoid::PolyLine route110 = connRef110->displayRoute();
if (fabs(route110.ps[route110.size() - 3].y - checkpointY) < 2)
{
succeeded = false;
}
delete router;
return (succeeded) ? 0 : 1;
};
int main(void) {
Router *router = new Router(
PolyLineRouting | OrthogonalRouting);
router->setRoutingPenalty((PenaltyType)0, 50);
router->setRoutingPenalty((PenaltyType)1, 0);
router->setRoutingPenalty((PenaltyType)2, 0);
router->setRoutingPenalty((PenaltyType)3, 4000);
router->setRoutingPenalty((PenaltyType)4, 0);
router->setRoutingPenalty((PenaltyType)5, 100);
router->setRoutingOption((RoutingOption)0, true);
router->setRoutingOption((RoutingOption)1, true);
router->setRoutingOption((RoutingOption)2, false);
/*
Polygon poly1(4);
poly1.ps[0] = Point(541.101, 45);
poly1.ps[1] = Point(541.101, 89);
poly1.ps[2] = Point(274.101, 89);
poly1.ps[3] = Point(274.101, 45);
new ShapeRef(router, poly1, 1);
Polygon poly2(4);
poly2.ps[0] = Point(445.857, 111);
poly2.ps[1] = Point(445.857, 276);
poly2.ps[2] = Point(309.857, 276);
poly2.ps[3] = Point(309.857, 111);
new ShapeRef(router, poly2, 2);
*/
Polygon poly3(4);
poly3.ps[0] = Point(328, 368);
poly3.ps[1] = Point(328, 400);
poly3.ps[2] = Point(308, 400);
poly3.ps[3] = Point(308, 368);
new ShapeRef(router, poly3, 3);
Polygon poly4(4);
poly4.ps[0] = Point(328, 492);
poly4.ps[1] = Point(328, 524);
poly4.ps[2] = Point(308, 524);
poly4.ps[3] = Point(308, 492);
new ShapeRef(router, poly4, 4);
/*
Polygon poly5(4);
poly5.ps[0] = Point(328, 629);
poly5.ps[1] = Point(328, 661);
poly5.ps[2] = Point(308, 661);
poly5.ps[3] = Point(308, 629);
new ShapeRef(router, poly5, 5);
Polygon poly6(4);
poly6.ps[0] = Point(511.857, 308);
poly6.ps[1] = Point(511.857, 328);
poly6.ps[2] = Point(479.857, 328);
poly6.ps[3] = Point(479.857, 308);
new ShapeRef(router, poly6, 6);
Polygon poly7(4);
poly7.ps[0] = Point(518.357, 629);
poly7.ps[1] = Point(518.357, 661);
poly7.ps[2] = Point(498.357, 661);
poly7.ps[3] = Point(498.357, 629);
new ShapeRef(router, poly7, 7);
Polygon poly8(4);
poly8.ps[0] = Point(827.857, 210);
poly8.ps[1] = Point(827.857, 270);
poly8.ps[2] = Point(545.857, 270);
poly8.ps[3] = Point(545.857, 210);
new ShapeRef(router, poly8, 8);
Polygon poly9(4);
poly9.ps[0] = Point(805.357, 409);
poly9.ps[1] = Point(805.357, 469);
poly9.ps[2] = Point(572.357, 469);
poly9.ps[3] = Point(572.357, 409);
new ShapeRef(router, poly9, 9);
Polygon poly10(4);
poly10.ps[0] = Point(157.5, 426);
poly10.ps[1] = Point(157.5, 458);
poly10.ps[2] = Point(137.5, 458);
poly10.ps[3] = Point(137.5, 426);
new ShapeRef(router, poly10, 10);
Polygon poly11(4);
poly11.ps[0] = Point(276, 597.655);
poly11.ps[1] = Point(276, 657.655);
poly11.ps[2] = Point(45, 657.655);
poly11.ps[3] = Point(45, 597.655);
new ShapeRef(router, poly11, 11);
Polygon poly12(4);
poly12.ps[0] = Point(349, 287);
poly12.ps[1] = Point(349, 349);
poly12.ps[2] = Point(287, 349);
poly12.ps[3] = Point(287, 287);
new ShapeRef(router, poly12, 12);
*/
Polygon poly13(4);
poly13.ps[0] = Point(349, 415);
poly13.ps[1] = Point(349, 477);
poly13.ps[2] = Point(287, 477);
poly13.ps[3] = Point(287, 415);
new ShapeRef(router, poly13, 13);
/*
Polygon poly14(4);
poly14.ps[0] = Point(349, 676);
poly14.ps[1] = Point(349, 738);
poly14.ps[2] = Point(287, 738);
poly14.ps[3] = Point(287, 676);
new ShapeRef(router, poly14, 14);
Polygon poly15(4);
poly15.ps[0] = Point(349, 552);
poly15.ps[1] = Point(349, 614);
poly15.ps[2] = Point(287, 614);
poly15.ps[3] = Point(287, 552);
new ShapeRef(router, poly15, 15);
Polygon poly16(4);
poly16.ps[0] = Point(539.357, 676);
poly16.ps[1] = Point(539.357, 738);
poly16.ps[2] = Point(477.357, 738);
poly16.ps[3] = Point(477.357, 676);
new ShapeRef(router, poly16, 16);
*/
Polygon poly17(4);
poly17.ps[0] = Point(640.857, 336);
poly17.ps[1] = Point(640.857, 398);
poly17.ps[2] = Point(578.857, 398);
poly17.ps[3] = Point(578.857, 336);
new ShapeRef(router, poly17, 17);
Polygon poly18(4);
poly18.ps[0] = Point(404, 364);
poly18.ps[1] = Point(404, 404);
poly18.ps[2] = Point(328, 404);
poly18.ps[3] = Point(328, 364);
new ShapeRef(router, poly18, 18);
Polygon poly19(4);
poly19.ps[0] = Point(404, 488);
poly19.ps[1] = Point(404, 528);
poly19.ps[2] = Point(328, 528);
poly19.ps[3] = Point(328, 488);
new ShapeRef(router, poly19, 19);
/*
Polygon poly20(4);
poly20.ps[0] = Point(404, 625);
poly20.ps[1] = Point(404, 665);
poly20.ps[2] = Point(328, 665);
poly20.ps[3] = Point(328, 625);
new ShapeRef(router, poly20, 20);
Polygon poly21(4);
poly21.ps[0] = Point(523.857, 248);
poly21.ps[1] = Point(523.857, 308);
poly21.ps[2] = Point(467.857, 308);
poly21.ps[3] = Point(467.857, 248);
new ShapeRef(router, poly21, 21);
Polygon poly22(4);
poly22.ps[0] = Point(594.357, 625);
poly22.ps[1] = Point(594.357, 665);
poly22.ps[2] = Point(518.357, 665);
poly22.ps[3] = Point(518.357, 625);
new ShapeRef(router, poly22, 22);
Polygon poly23(4);
poly23.ps[0] = Point(137.5, 422);
poly23.ps[1] = Point(137.5, 462);
poly23.ps[2] = Point(61.5, 462);
poly23.ps[3] = Point(61.5, 422);
new ShapeRef(router, poly23, 23);
Polygon poly24(4);
poly24.ps[0] = Point(398.357, 216.5);
poly24.ps[1] = Point(398.357, 276.5);
poly24.ps[2] = Point(358.357, 276.5);
poly24.ps[3] = Point(358.357, 216.5);
new ShapeRef(router, poly24, 24);
Polygon poly25(4);
poly25.ps[0] = Point(606.357, 220.5);
poly25.ps[1] = Point(606.357, 260.5);
poly25.ps[2] = Point(546.357, 260.5);
poly25.ps[3] = Point(546.357, 220.5);
new ShapeRef(router, poly25, 25);
*/
Polygon poly26(4);
poly26.ps[0] = Point(632.857, 419.5);
poly26.ps[1] = Point(632.857, 459.5);
poly26.ps[2] = Point(572.857, 459.5);
poly26.ps[3] = Point(572.857, 419.5);
new ShapeRef(router, poly26, 26);
/*
Polygon poly27(4);
poly27.ps[0] = Point(276.5, 608.155);
poly27.ps[1] = Point(276.5, 648.155);
poly27.ps[2] = Point(216.5, 648.155);
poly27.ps[3] = Point(216.5, 608.155);
new ShapeRef(router, poly27, 27);
ConnRef *connRef28 = new ConnRef(router, 28);
ConnEnd srcPt28(Point(318, 399), 2);
connRef28->setSourceEndpoint(srcPt28);
ConnEnd dstPt28(Point(318, 446), 15);
connRef28->setDestEndpoint(dstPt28);
connRef28->setRoutingType((ConnType)2);
ConnRef *connRef29 = new ConnRef(router, 29);
ConnEnd srcPt29(Point(318, 523), 2);
connRef29->setSourceEndpoint(srcPt29);
ConnEnd dstPt29(Point(318, 583), 15);
connRef29->setDestEndpoint(dstPt29);
connRef29->setRoutingType((ConnType)2);
*/
ConnRef *connRef30 = new ConnRef(router, 30);
ConnEnd srcPt30(Point(318, 523), 2);
connRef30->setSourceEndpoint(srcPt30);
ConnEnd dstPt30(Point(609.857, 367), 15);
connRef30->setDestEndpoint(dstPt30);
connRef30->setRoutingType((ConnType)2);
/*
ConnRef *connRef31 = new ConnRef(router, 31);
ConnEnd srcPt31(Point(318, 660), 2);
connRef31->setSourceEndpoint(srcPt31);
ConnEnd dstPt31(Point(318, 707), 15);
connRef31->setDestEndpoint(dstPt31);
connRef31->setRoutingType((ConnType)2);
ConnRef *connRef32 = new ConnRef(router, 32);
ConnEnd srcPt32(Point(480.857, 318), 4);
connRef32->setSourceEndpoint(srcPt32);
ConnEnd dstPt32(Point(318, 318), 15);
connRef32->setDestEndpoint(dstPt32);
connRef32->setRoutingType((ConnType)2);
ConnRef *connRef33 = new ConnRef(router, 33);
ConnEnd srcPt33(Point(510.857, 318), 8);
connRef33->setSourceEndpoint(srcPt33);
ConnEnd dstPt33(Point(609.857, 367), 15);
connRef33->setDestEndpoint(dstPt33);
connRef33->setRoutingType((ConnType)2);
ConnRef *connRef34 = new ConnRef(router, 34);
ConnEnd srcPt34(Point(508.357, 630), 1);
connRef34->setSourceEndpoint(srcPt34);
ConnEnd dstPt34(Point(318, 583), 15);
connRef34->setDestEndpoint(dstPt34);
connRef34->setRoutingType((ConnType)2);
ConnRef *connRef35 = new ConnRef(router, 35);
ConnEnd srcPt35(Point(147.5, 427), 1);
connRef35->setSourceEndpoint(srcPt35);
ConnEnd dstPt35(Point(318, 318), 15);
connRef35->setDestEndpoint(dstPt35);
connRef35->setRoutingType((ConnType)2);
ConnRef *connRef36 = new ConnRef(router, 36);
ConnEnd srcPt36(Point(147.5, 457), 2);
connRef36->setSourceEndpoint(srcPt36);
ConnEnd dstPt36(Point(318, 583), 15);
connRef36->setDestEndpoint(dstPt36);
connRef36->setRoutingType((ConnType)2);
ConnRef *connRef37 = new ConnRef(router, 37);
ConnEnd srcPt37(Point(318, 446), 15);
connRef37->setSourceEndpoint(srcPt37);
ConnEnd dstPt37(Point(318, 493), 1);
connRef37->setDestEndpoint(dstPt37);
connRef37->setRoutingType((ConnType)2);
ConnRef *connRef38 = new ConnRef(router, 38);
ConnEnd srcPt38(Point(508.357, 660), 2);
connRef38->setSourceEndpoint(srcPt38);
ConnEnd dstPt38(Point(508.357, 707), 15);
connRef38->setDestEndpoint(dstPt38);
connRef38->setRoutingType((ConnType)2);
ConnRef *connRef39 = new ConnRef(router, 39);
ConnEnd srcPt39(Point(376, 384), 4);
connRef39->setSourceEndpoint(srcPt39);
ConnEnd dstPt39(Point(318, 384), 8);
connRef39->setDestEndpoint(dstPt39);
connRef39->setRoutingType((ConnType)2);
ConnRef *connRef40 = new ConnRef(router, 40);
ConnEnd srcPt40(Point(376, 508), 4);
connRef40->setSourceEndpoint(srcPt40);
ConnEnd dstPt40(Point(318, 508), 8);
connRef40->setDestEndpoint(dstPt40);
connRef40->setRoutingType((ConnType)2);
ConnRef *connRef41 = new ConnRef(router, 41);
ConnEnd srcPt41(Point(376, 645), 4);
connRef41->setSourceEndpoint(srcPt41);
ConnEnd dstPt41(Point(318, 645), 8);
connRef41->setDestEndpoint(dstPt41);
connRef41->setRoutingType((ConnType)2);
ConnRef *connRef42 = new ConnRef(router, 42);
ConnEnd srcPt42(Point(495.857, 268), 2);
connRef42->setSourceEndpoint(srcPt42);
ConnEnd dstPt42(Point(495.857, 318), 1);
connRef42->setDestEndpoint(dstPt42);
connRef42->setRoutingType((ConnType)2);
ConnRef *connRef43 = new ConnRef(router, 43);
ConnEnd srcPt43(Point(566.357, 645), 4);
connRef43->setSourceEndpoint(srcPt43);
ConnEnd dstPt43(Point(508.357, 645), 8);
connRef43->setDestEndpoint(dstPt43);
connRef43->setRoutingType((ConnType)2);
ConnRef *connRef44 = new ConnRef(router, 44);
ConnEnd srcPt44(Point(89.5, 442), 8);
connRef44->setSourceEndpoint(srcPt44);
ConnEnd dstPt44(Point(147.5, 442), 4);
connRef44->setDestEndpoint(dstPt44);
connRef44->setRoutingType((ConnType)2);
ConnRef *connRef45 = new ConnRef(router, 45);
ConnEnd srcPt45(Point(318, 318), 15);
connRef45->setSourceEndpoint(srcPt45);
ConnEnd dstPt45(Point(318, 369), 1);
connRef45->setDestEndpoint(dstPt45);
connRef45->setRoutingType((ConnType)2);
*/
ConnRef *connRef46 = new ConnRef(router, 46);
ConnEnd srcPt46(Point(609.857, 367), 15);
connRef46->setSourceEndpoint(srcPt46);
ConnEnd dstPt46(Point(318, 369), 1);
connRef46->setDestEndpoint(dstPt46);
connRef46->setRoutingType((ConnType)2);
/*
ConnRef *connRef47 = new ConnRef(router, 47);
ConnEnd srcPt47(Point(318, 583), 15);
connRef47->setSourceEndpoint(srcPt47);
ConnEnd dstPt47(Point(318, 630), 1);
connRef47->setDestEndpoint(dstPt47);
connRef47->setRoutingType((ConnType)2);
ConnRef *connRef48 = new ConnRef(router, 48);
ConnEnd srcPt48(Point(318, 318), 15);
connRef48->setSourceEndpoint(srcPt48);
ConnEnd dstPt48(Point(378.357, 271.5), 2);
connRef48->setDestEndpoint(dstPt48);
connRef48->setRoutingType((ConnType)2);
ConnRef *connRef49 = new ConnRef(router, 49);
ConnEnd srcPt49(Point(318, 318), 15);
connRef49->setSourceEndpoint(srcPt49);
ConnEnd dstPt49(Point(551.357, 240.5), 4);
connRef49->setDestEndpoint(dstPt49);
connRef49->setRoutingType((ConnType)2);
*/
ConnRef *connRef50 = new ConnRef(router, 50);
ConnEnd srcPt50(Point(609.857, 367), 15);
connRef50->setSourceEndpoint(srcPt50);
ConnEnd dstPt50(Point(577.857, 439.5), 4);
connRef50->setDestEndpoint(dstPt50);
connRef50->setRoutingType((ConnType)2);
/*
ConnRef *connRef51 = new ConnRef(router, 51);
ConnEnd srcPt51(Point(318, 583), 15);
connRef51->setSourceEndpoint(srcPt51);
ConnEnd dstPt51(Point(271.5, 628.155), 8);
connRef51->setDestEndpoint(dstPt51);
connRef51->setRoutingType((ConnType)2);
*/
router->processTransaction();
router->outputDiagram("output/finalSegmentNudging2");
bool atEnds = true;
bool overlap = router->existsOrthogonalFixedSegmentOverlap(atEnds);
delete router;
return (overlap) ? 1 : 0;
};
int main(void) {
Router *router = new Router(
PolyLineRouting | OrthogonalRouting);
router->setRoutingPenalty((PenaltyType)0, 50);
router->setRoutingPenalty((PenaltyType)1, 0);
router->setRoutingPenalty((PenaltyType)2, 200);
router->setRoutingPenalty((PenaltyType)3, 4000);
router->setRoutingPenalty((PenaltyType)4, 110);
router->setRoutingPenalty((PenaltyType)5, 100);
router->setRoutingOption((RoutingOption)0, false);
router->setRoutingOption((RoutingOption)1, true);
router->setRoutingParameter(idealNudgingDistance, 25);
Polygon poly3075375(4);
poly3075375.ps[0] = Point(51925, 52070);
poly3075375.ps[1] = Point(51925, 52130);
poly3075375.ps[2] = Point(51725, 52130);
poly3075375.ps[3] = Point(51725, 52070);
new ShapeRef(router, poly3075375, 3075375);
Polygon poly101599344(4);
poly101599344.ps[0] = Point(50275, 52410);
poly101599344.ps[1] = Point(50275, 52490);
poly101599344.ps[2] = Point(50075, 52490);
poly101599344.ps[3] = Point(50075, 52410);
new ShapeRef(router, poly101599344, 101599344);
Polygon poly127957550(4);
poly127957550.ps[0] = Point(52010, 51617);
poly127957550.ps[1] = Point(52010, 51683);
poly127957550.ps[2] = Point(51890, 51683);
poly127957550.ps[3] = Point(51890, 51617);
ShapeRef *shapeRef127957550 = new ShapeRef(router, poly127957550, 127957550);
new ShapeConnectionPin(shapeRef127957550, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 1);
new ShapeConnectionPin(shapeRef127957550, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 2);
new ShapeConnectionPin(shapeRef127957550, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 4);
new ShapeConnectionPin(shapeRef127957550, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 8);
Polygon poly129612347(4);
poly129612347.ps[0] = Point(51900, 51696);
poly129612347.ps[1] = Point(51900, 51754);
poly129612347.ps[2] = Point(51815, 51754);
poly129612347.ps[3] = Point(51815, 51696);
new ShapeRef(router, poly129612347, 129612347);
Polygon poly203389050(4);
poly203389050.ps[0] = Point(51825, 52260);
poly203389050.ps[1] = Point(51825, 52340);
poly203389050.ps[2] = Point(51625, 52340);
poly203389050.ps[3] = Point(51625, 52260);
new ShapeRef(router, poly203389050, 203389050);
Polygon poly208676910(4);
poly208676910.ps[0] = Point(51950, 51760);
poly208676910.ps[1] = Point(51950, 51840);
poly208676910.ps[2] = Point(51750, 51840);
poly208676910.ps[3] = Point(51750, 51760);
new ShapeRef(router, poly208676910, 208676910);
Polygon poly219117032(4);
poly219117032.ps[0] = Point(50225, 52070);
poly219117032.ps[1] = Point(50225, 52130);
poly219117032.ps[2] = Point(50025, 52130);
poly219117032.ps[3] = Point(50025, 52070);
new ShapeRef(router, poly219117032, 219117032);
Polygon poly258454350(4);
poly258454350.ps[0] = Point(50185, 51617);
poly258454350.ps[1] = Point(50185, 51683);
poly258454350.ps[2] = Point(50065, 51683);
poly258454350.ps[3] = Point(50065, 51617);
ShapeRef *shapeRef258454350 = new ShapeRef(router, poly258454350, 258454350);
new ShapeConnectionPin(shapeRef258454350, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 1);
new ShapeConnectionPin(shapeRef258454350, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 2);
new ShapeConnectionPin(shapeRef258454350, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 4);
new ShapeConnectionPin(shapeRef258454350, 2147483646, 0.5, 0.5, true, 0, (ConnDirFlags) 8);
Polygon poly274504590(4);
poly274504590.ps[0] = Point(51400, 52470);
poly274504590.ps[1] = Point(51400, 52530);
poly274504590.ps[2] = Point(51150, 52530);
poly274504590.ps[3] = Point(51150, 52470);
new ShapeRef(router, poly274504590, 274504590);
Polygon poly320957826(4);
poly320957826.ps[0] = Point(50275, 51910);
poly320957826.ps[1] = Point(50275, 51990);
poly320957826.ps[2] = Point(50075, 51990);
poly320957826.ps[3] = Point(50075, 51910);
new ShapeRef(router, poly320957826, 320957826);
Polygon poly368436384(4);
poly368436384.ps[0] = Point(50325, 51696);
poly368436384.ps[1] = Point(50325, 51754);
poly368436384.ps[2] = Point(50240, 51754);
poly368436384.ps[3] = Point(50240, 51696);
new ShapeRef(router, poly368436384, 368436384);
Polygon poly381499178(4);
poly381499178.ps[0] = Point(51850, 51345);
poly381499178.ps[1] = Point(51850, 51405);
poly381499178.ps[2] = Point(51650, 51405);
poly381499178.ps[3] = Point(51650, 51345);
new ShapeRef(router, poly381499178, 381499178);
Polygon poly426410694(4);
poly426410694.ps[0] = Point(50325, 52270);
poly426410694.ps[1] = Point(50325, 52330);
poly426410694.ps[2] = Point(50125, 52330);
poly426410694.ps[3] = Point(50125, 52270);
new ShapeRef(router, poly426410694, 426410694);
Polygon poly428912890(4);
poly428912890.ps[0] = Point(51825, 51510);
poly428912890.ps[1] = Point(51825, 51590);
poly428912890.ps[2] = Point(51625, 51590);
poly428912890.ps[3] = Point(51625, 51510);
new ShapeRef(router, poly428912890, 428912890);
Polygon poly468897320(4);
poly468897320.ps[0] = Point(50425, 51520);
poly468897320.ps[1] = Point(50425, 51580);
poly468897320.ps[2] = Point(50225, 51580);
poly468897320.ps[3] = Point(50225, 51520);
new ShapeRef(router, poly468897320, 468897320);
Polygon poly517518507(4);
poly517518507.ps[0] = Point(51925, 51910);
poly517518507.ps[1] = Point(51925, 51990);
poly517518507.ps[2] = Point(51725, 51990);
poly517518507.ps[3] = Point(51725, 51910);
new ShapeRef(router, poly517518507, 517518507);
Polygon poly565878858(4);
poly565878858.ps[0] = Point(51160, 52500);
poly565878858.ps[1] = Point(51160, 52810);
poly565878858.ps[2] = Point(50890, 52810);
poly565878858.ps[3] = Point(50890, 52500);
new ShapeRef(router, poly565878858, 565878858);
Polygon poly706147100(4);
poly706147100.ps[0] = Point(51160, 50990);
poly706147100.ps[1] = Point(51160, 51300);
poly706147100.ps[2] = Point(50890, 51300);
poly706147100.ps[3] = Point(50890, 50990);
new ShapeRef(router, poly706147100, 706147100);
Polygon poly746254622(4);
poly746254622.ps[0] = Point(50275, 51760);
poly746254622.ps[1] = Point(50275, 51840);
poly746254622.ps[2] = Point(50075, 51840);
poly746254622.ps[3] = Point(50075, 51760);
new ShapeRef(router, poly746254622, 746254622);
Polygon poly829835240(4);
poly829835240.ps[0] = Point(50425, 51360);
poly829835240.ps[1] = Point(50425, 51440);
poly829835240.ps[2] = Point(50225, 51440);
poly829835240.ps[3] = Point(50225, 51360);
new ShapeRef(router, poly829835240, 829835240);
Polygon poly157548160(4);
poly157548160.ps[0] = Point(51550, 51500);
poly157548160.ps[1] = Point(51550, 52225);
poly157548160.ps[2] = Point(50525, 52225);
poly157548160.ps[3] = Point(50525, 51500);
new ShapeRef(router, poly157548160, 157548160);
ConnRef *connRef6675422 = new ConnRef(router, 6675422);
ConnEnd srcPt6675422(Point(51100, 51290), 2);
connRef6675422->setSourceEndpoint(srcPt6675422);
ConnEnd dstPt6675422(Point(51150, 51510), 1);
connRef6675422->setDestEndpoint(dstPt6675422);
connRef6675422->setRoutingType((ConnType)2);
ConnRef *connRef13259320 = new ConnRef(router, 13259320);
ConnEnd srcPt13259320(Point(50535, 51675), 4);
connRef13259320->setSourceEndpoint(srcPt13259320);
ConnEnd dstPt13259320(Point(50315, 51725), 8);
connRef13259320->setDestEndpoint(dstPt13259320);
connRef13259320->setRoutingType((ConnType)2);
ConnRef *connRef17108208 = new ConnRef(router, 17108208);
ConnEnd srcPt17108208(Point(51540, 52050), 8);
connRef17108208->setSourceEndpoint(srcPt17108208);
ConnEnd dstPt17108208(Point(51735, 52100), 4);
connRef17108208->setDestEndpoint(dstPt17108208);
connRef17108208->setRoutingType((ConnType)2);
ConnRef *connRef41442471 = new ConnRef(router, 41442471);
ConnEnd srcPt41442471(Point(51075, 52215), 2);
connRef41442471->setSourceEndpoint(srcPt41442471);
ConnEnd dstPt41442471(Point(51050, 52510), 1);
connRef41442471->setDestEndpoint(dstPt41442471);
connRef41442471->setRoutingType((ConnType)2);
ConnRef *connRef45863720 = new ConnRef(router, 45863720);
ConnEnd srcPt45863720(Point(51660, 51375), 4);
connRef45863720->setSourceEndpoint(srcPt45863720);
ConnEnd dstPt45863720(Point(51300, 51510), 1);
connRef45863720->setDestEndpoint(dstPt45863720);
connRef45863720->setRoutingType((ConnType)2);
ConnRef *connRef52653348 = new ConnRef(router, 52653348);
ConnEnd srcPt52653348(Point(50535, 52050), 4);
connRef52653348->setSourceEndpoint(srcPt52653348);
ConnEnd dstPt52653348(Point(50215, 52100), 8);
connRef52653348->setDestEndpoint(dstPt52653348);
connRef52653348->setRoutingType((ConnType)2);
ConnRef *connRef57649636 = new ConnRef(router, 57649636);
ConnEnd srcPt57649636(Point(51540, 52125), 8);
connRef57649636->setSourceEndpoint(srcPt57649636);
ConnEnd dstPt57649636(Point(51915, 52100), 8);
connRef57649636->setDestEndpoint(dstPt57649636);
connRef57649636->setRoutingType((ConnType)2);
ConnRef *connRef64735671 = new ConnRef(router, 64735671);
ConnEnd srcPt64735671(Point(51375, 52215), 2);
connRef64735671->setSourceEndpoint(srcPt64735671);
ConnEnd dstPt64735671(Point(51815, 52300), 8);
connRef64735671->setDestEndpoint(dstPt64735671);
connRef64735671->setRoutingType((ConnType)2);
ConnRef *connRef81789576 = new ConnRef(router, 81789576);
ConnEnd srcPt81789576(Point(50950, 51290), 2);
connRef81789576->setSourceEndpoint(srcPt81789576);
ConnEnd dstPt81789576(Point(50925, 51510), 1);
connRef81789576->setDestEndpoint(dstPt81789576);
connRef81789576->setRoutingType((ConnType)2);
ConnRef *connRef87742344 = new ConnRef(router, 87742344);
ConnEnd srcPt87742344(Point(51540, 51600), 8);
connRef87742344->setSourceEndpoint(srcPt87742344);
ConnEnd dstPt87742344(shapeRef127957550, 2147483646);
connRef87742344->setDestEndpoint(dstPt87742344);
connRef87742344->setRoutingType((ConnType)2);
ConnRef *connRef92624219 = new ConnRef(router, 92624219);
ConnEnd srcPt92624219(Point(51450, 52215), 2);
connRef92624219->setSourceEndpoint(srcPt92624219);
ConnEnd dstPt92624219(Point(51635, 52300), 4);
connRef92624219->setDestEndpoint(dstPt92624219);
connRef92624219->setRoutingType((ConnType)2);
ConnRef *connRef126568050 = new ConnRef(router, 126568050);
ConnEnd srcPt126568050(Point(51540, 51975), 8);
connRef126568050->setSourceEndpoint(srcPt126568050);
ConnEnd dstPt126568050(Point(51915, 51950), 8);
connRef126568050->setDestEndpoint(dstPt126568050);
connRef126568050->setRoutingType((ConnType)2);
ConnRef *connRef128113340 = new ConnRef(router, 128113340);
ConnEnd srcPt128113340(Point(51300, 52215), 2);
connRef128113340->setSourceEndpoint(srcPt128113340);
ConnEnd dstPt128113340(Point(51390, 52500), 8);
connRef128113340->setDestEndpoint(dstPt128113340);
connRef128113340->setRoutingType((ConnType)2);
ConnRef *connRef157642749 = new ConnRef(router, 157642749);
ConnEnd srcPt157642749(Point(51225, 52215), 2);
connRef157642749->setSourceEndpoint(srcPt157642749);
// Problem point:
ConnEnd dstPt157642749(Point(51160, 52500), 4);
connRef157642749->setDestEndpoint(dstPt157642749);
connRef157642749->setRoutingType((ConnType)2);
ConnRef *connRef182970626 = new ConnRef(router, 182970626);
ConnEnd srcPt182970626(Point(51000, 52215), 2);
connRef182970626->setSourceEndpoint(srcPt182970626);
ConnEnd dstPt182970626(Point(51000, 52510), 1);
connRef182970626->setDestEndpoint(dstPt182970626);
connRef182970626->setRoutingType((ConnType)2);
ConnRef *connRef191618599 = new ConnRef(router, 191618599);
ConnEnd srcPt191618599(Point(50535, 51900), 4);
connRef191618599->setSourceEndpoint(srcPt191618599);
ConnEnd dstPt191618599(Point(50265, 51950), 8);
connRef191618599->setDestEndpoint(dstPt191618599);
connRef191618599->setRoutingType((ConnType)2);
ConnRef *connRef215646300 = new ConnRef(router, 215646300);
ConnEnd srcPt215646300(Point(50415, 51400), 8);
connRef215646300->setSourceEndpoint(srcPt215646300);
ConnEnd dstPt215646300(Point(50775, 51510), 1);
connRef215646300->setDestEndpoint(dstPt215646300);
connRef215646300->setRoutingType((ConnType)2);
ConnRef *connRef217181718 = new ConnRef(router, 217181718);
ConnEnd srcPt217181718(Point(51000, 51290), 2);
connRef217181718->setSourceEndpoint(srcPt217181718);
ConnEnd dstPt217181718(Point(51000, 51510), 1);
connRef217181718->setDestEndpoint(dstPt217181718);
connRef217181718->setRoutingType((ConnType)2);
ConnRef *connRef217236398 = new ConnRef(router, 217236398);
ConnEnd srcPt217236398(Point(50700, 52215), 2);
connRef217236398->setSourceEndpoint(srcPt217236398);
ConnEnd dstPt217236398(Point(50135, 52300), 4);
connRef217236398->setDestEndpoint(dstPt217236398);
connRef217236398->setRoutingType((ConnType)2);
ConnRef *connRef227676560 = new ConnRef(router, 227676560);
ConnEnd srcPt227676560(Point(50850, 51510), 1);
connRef227676560->setSourceEndpoint(srcPt227676560);
ConnEnd dstPt227676560(Point(50235, 51400), 4);
connRef227676560->setDestEndpoint(dstPt227676560);
connRef227676560->setRoutingType((ConnType)2);
ConnRef *connRef235740708 = new ConnRef(router, 235740708);
ConnEnd srcPt235740708(Point(51540, 51675), 8);
connRef235740708->setSourceEndpoint(srcPt235740708);
ConnEnd dstPt235740708(Point(51870, 51725), 8);
connRef235740708->setDestEndpoint(dstPt235740708);
connRef235740708->setRoutingType((ConnType)2);
ConnRef *connRef307166980 = new ConnRef(router, 307166980);
ConnEnd srcPt307166980(Point(50925, 52215), 2);
connRef307166980->setSourceEndpoint(srcPt307166980);
ConnEnd dstPt307166980(Point(50950, 52510), 1);
connRef307166980->setDestEndpoint(dstPt307166980);
connRef307166980->setRoutingType((ConnType)2);
ConnRef *connRef314353850 = new ConnRef(router, 314353850);
ConnEnd srcPt314353850(Point(51050, 51290), 2);
connRef314353850->setSourceEndpoint(srcPt314353850);
ConnEnd dstPt314353850(Point(51075, 51510), 1);
connRef314353850->setDestEndpoint(dstPt314353850);
connRef314353850->setRoutingType((ConnType)2);
ConnRef *connRef356343444 = new ConnRef(router, 356343444);
ConnEnd srcPt356343444(Point(50625, 51510), 1);
connRef356343444->setSourceEndpoint(srcPt356343444);
ConnEnd dstPt356343444(Point(50415, 51550), 8);
connRef356343444->setDestEndpoint(dstPt356343444);
connRef356343444->setRoutingType((ConnType)2);
ConnRef *connRef401560509 = new ConnRef(router, 401560509);
ConnEnd srcPt401560509(Point(50625, 52215), 2);
connRef401560509->setSourceEndpoint(srcPt401560509);
ConnEnd dstPt401560509(Point(50315, 52300), 8);
connRef401560509->setDestEndpoint(dstPt401560509);
connRef401560509->setRoutingType((ConnType)2);
ConnRef *connRef413072940 = new ConnRef(router, 413072940);
ConnEnd srcPt413072940(Point(51840, 51375), 8);
connRef413072940->setSourceEndpoint(srcPt413072940);
ConnEnd dstPt413072940(Point(51225, 51510), 1);
connRef413072940->setDestEndpoint(dstPt413072940);
connRef413072940->setRoutingType((ConnType)2);
ConnRef *connRef413766381 = new ConnRef(router, 413766381);
ConnEnd srcPt413766381(Point(50535, 51750), 4);
connRef413766381->setSourceEndpoint(srcPt413766381);
ConnEnd dstPt413766381(Point(50265, 51800), 8);
connRef413766381->setDestEndpoint(dstPt413766381);
connRef413766381->setRoutingType((ConnType)2);
ConnRef *connRef422359365 = new ConnRef(router, 422359365);
ConnEnd srcPt422359365(Point(50535, 51825), 4);
connRef422359365->setSourceEndpoint(srcPt422359365);
ConnEnd dstPt422359365(Point(50085, 51800), 4);
connRef422359365->setDestEndpoint(dstPt422359365);
connRef422359365->setRoutingType((ConnType)2);
ConnRef *connRef427415850 = new ConnRef(router, 427415850);
ConnEnd srcPt427415850(Point(50775, 52215), 2);
connRef427415850->setSourceEndpoint(srcPt427415850);
ConnEnd dstPt427415850(Point(50265, 52450), 8);
connRef427415850->setDestEndpoint(dstPt427415850);
connRef427415850->setRoutingType((ConnType)2);
ConnRef *connRef444649182 = new ConnRef(router, 444649182);
ConnEnd srcPt444649182(Point(51540, 51750), 8);
connRef444649182->setSourceEndpoint(srcPt444649182);
ConnEnd dstPt444649182(Point(51760, 51800), 4);
connRef444649182->setDestEndpoint(dstPt444649182);
connRef444649182->setRoutingType((ConnType)2);
ConnRef *connRef505297694 = new ConnRef(router, 505297694);
ConnEnd srcPt505297694(Point(50700, 51510), 1);
connRef505297694->setSourceEndpoint(srcPt505297694);
ConnEnd dstPt505297694(Point(50235, 51550), 4);
connRef505297694->setDestEndpoint(dstPt505297694);
connRef505297694->setRoutingType((ConnType)2);
ConnRef *connRef528809632 = new ConnRef(router, 528809632);
ConnEnd srcPt528809632(Point(51540, 51900), 8);
connRef528809632->setSourceEndpoint(srcPt528809632);
ConnEnd dstPt528809632(Point(51735, 51950), 4);
connRef528809632->setDestEndpoint(dstPt528809632);
connRef528809632->setRoutingType((ConnType)2);
ConnRef *connRef548127810 = new ConnRef(router, 548127810);
ConnEnd srcPt548127810(Point(50535, 51975), 4);
connRef548127810->setSourceEndpoint(srcPt548127810);
ConnEnd dstPt548127810(Point(50085, 51950), 4);
connRef548127810->setDestEndpoint(dstPt548127810);
connRef548127810->setRoutingType((ConnType)2);
ConnRef *connRef648819584 = new ConnRef(router, 648819584);
ConnEnd srcPt648819584(Point(51540, 51825), 8);
connRef648819584->setSourceEndpoint(srcPt648819584);
ConnEnd dstPt648819584(Point(51940, 51800), 8);
connRef648819584->setDestEndpoint(dstPt648819584);
connRef648819584->setRoutingType((ConnType)2);
ConnRef *connRef651183694 = new ConnRef(router, 651183694);
ConnEnd srcPt651183694(Point(51635, 51550), 4);
connRef651183694->setSourceEndpoint(srcPt651183694);
ConnEnd dstPt651183694(Point(51450, 51510), 1);
connRef651183694->setDestEndpoint(dstPt651183694);
connRef651183694->setRoutingType((ConnType)2);
ConnRef *connRef655025700 = new ConnRef(router, 655025700);
ConnEnd srcPt655025700(Point(51150, 52215), 2);
connRef655025700->setSourceEndpoint(srcPt655025700);
ConnEnd dstPt655025700(Point(51100, 52510), 1);
connRef655025700->setDestEndpoint(dstPt655025700);
connRef655025700->setRoutingType((ConnType)2);
ConnRef *connRef662151765 = new ConnRef(router, 662151765);
ConnEnd srcPt662151765(Point(50535, 51600), 4);
connRef662151765->setSourceEndpoint(srcPt662151765);
ConnEnd dstPt662151765(shapeRef258454350, 2147483646);
connRef662151765->setDestEndpoint(dstPt662151765);
connRef662151765->setRoutingType((ConnType)2);
ConnRef *connRef678159455 = new ConnRef(router, 678159455);
ConnEnd srcPt678159455(Point(51815, 51550), 8);
connRef678159455->setSourceEndpoint(srcPt678159455);
ConnEnd dstPt678159455(Point(51375, 51510), 1);
connRef678159455->setDestEndpoint(dstPt678159455);
connRef678159455->setRoutingType((ConnType)2);
ConnRef *connRef803304040 = new ConnRef(router, 803304040);
ConnEnd srcPt803304040(Point(50850, 52215), 2);
connRef803304040->setSourceEndpoint(srcPt803304040);
ConnEnd dstPt803304040(Point(50085, 52450), 4);
connRef803304040->setDestEndpoint(dstPt803304040);
connRef803304040->setRoutingType((ConnType)2);
ConnRef *connRef960638799 = new ConnRef(router, 960638799);
ConnEnd srcPt960638799(Point(50535, 52125), 4);
connRef960638799->setSourceEndpoint(srcPt960638799);
ConnEnd dstPt960638799(Point(50035, 52100), 4);
connRef960638799->setDestEndpoint(dstPt960638799);
connRef960638799->setRoutingType((ConnType)2);
router->processTransaction();
router->outputDiagram("output/validPaths01");
int result = router->existsInvalidOrthogonalPaths();
delete router;
return result;
};
int main(void) {
Router *router = new Router(
PolyLineRouting | OrthogonalRouting);
router->setRoutingParameter((RoutingParameter)0, 50);
router->setRoutingParameter((RoutingParameter)1, 0);
router->setRoutingParameter((RoutingParameter)2, 0);
router->setRoutingParameter((RoutingParameter)3, 4000);
router->setRoutingParameter((RoutingParameter)4, 0);
router->setRoutingParameter((RoutingParameter)5, 100);
router->setRoutingParameter((RoutingParameter)6, 0);
router->setRoutingParameter((RoutingParameter)7, 4);
router->setRoutingOption((RoutingOption)0, true);
router->setRoutingOption((RoutingOption)1, true);
router->setRoutingOption((RoutingOption)2, false);
router->setRoutingOption((RoutingOption)3, false);
Polygon poly41(4);
poly41.ps[0] = Point(918.6758458220888, 441.0752314081785);
poly41.ps[1] = Point(918.6758458220888, 503.0752314081785);
poly41.ps[2] = Point(856.6758458220888, 503.0752314081785);
poly41.ps[3] = Point(856.6758458220888, 441.0752314081785);
new ShapeRef(router, poly41, 41);
Polygon poly43(4);
poly43.ps[0] = Point(710.6758458200889, 441.0752314081785);
poly43.ps[1] = Point(710.6758458200889, 461.0752314081785);
poly43.ps[2] = Point(678.6758458200889, 461.0752314081785);
poly43.ps[3] = Point(678.6758458200889, 441.0752314081785);
new ShapeRef(router, poly43, 43);
Polygon poly44(4);
poly44.ps[0] = Point(710.6758458200889, 483.0752314081785);
poly44.ps[1] = Point(710.6758458200889, 503.0752314081785);
poly44.ps[2] = Point(678.6758458200889, 503.0752314081785);
poly44.ps[3] = Point(678.6758458200889, 483.0752314081785);
new ShapeRef(router, poly44, 44);
ConnRef *connRef149 = new ConnRef(router, 149);
ConnEnd srcPt149(Point(709.6758458200889, 451.0752314081785), 8);
connRef149->setSourceEndpoint(srcPt149);
ConnEnd dstPt149(Point(887.6758458220888, 472.0752314081786), 15);
connRef149->setDestEndpoint(dstPt149);
connRef149->setRoutingType((ConnType)2);
std::vector<Checkpoint> checkpoints149(1);
checkpoints149[0] = Checkpoint(Point(732.6758458200889, 472.0752314081785), (ConnDirFlags) 15, (ConnDirFlags) 8);
connRef149->setRoutingCheckpoints(checkpoints149);
ConnRef *connRef150 = new ConnRef(router, 150);
ConnEnd srcPt150(Point(709.6758458200889, 493.0752314081785), 8);
connRef150->setSourceEndpoint(srcPt150);
ConnEnd dstPt150(Point(887.6758458220888, 472.0752314081786), 15);
connRef150->setDestEndpoint(dstPt150);
connRef150->setRoutingType((ConnType)2);
std::vector<Checkpoint> checkpoints150(1);
checkpoints150[0] = Checkpoint(Point(732.6758458200889, 472.0752314081785), (ConnDirFlags) 15, (ConnDirFlags) 8);
connRef150->setRoutingCheckpoints(checkpoints150);
router->processTransaction();
router->outputDiagram("output/checkpoints03");
bool succeeded = true;
Avoid::PolyLine route149 = connRef149->displayRoute();
Avoid::PolyLine route150 = connRef150->displayRoute();
if (route149.size() > 4 || route150.size() > 4)
{
// Five segments weren't merged into three. The segments in the shape
// on right weren't shifted to align with the segments going through
// the checkpoint.
succeeded = false;
}
if (succeeded == true)
{
// The segments were merged by were not centred around the
// checkpoint.
double checkpointY = 472.0752314081785;
if (fabs(route149.ps[route149.size() - 1].y - checkpointY) < 2)
{
succeeded = false;
}
if (fabs(route150.ps[route150.size() - 1].y - checkpointY) < 2)
{
succeeded = false;
}
}
delete router;
return (succeeded) ? 0 : 1;
};
int main(void) {
Router *router = new Router(OrthogonalRouting);
router->setRoutingParameter((RoutingParameter)0, 2);
router->setRoutingParameter((RoutingParameter)1, 0);
router->setRoutingParameter((RoutingParameter)2, 0);
router->setRoutingParameter((RoutingParameter)3, 4000);
router->setRoutingParameter((RoutingParameter)4, 9000);
router->setRoutingParameter((RoutingParameter)5, 0);
router->setRoutingParameter((RoutingParameter)6, 0);
router->setRoutingParameter((RoutingParameter)7, 16);
router->setRoutingParameter((RoutingParameter)8, 0);
router->setRoutingOption((RoutingOption)0, false);
router->setRoutingOption((RoutingOption)1, true);
router->setRoutingOption((RoutingOption)2, false);
router->setRoutingOption((RoutingOption)3, false);
router->setRoutingOption((RoutingOption)4, true);
router->setRoutingOption((RoutingOption)5, false);
router->setRoutingOption((RoutingOption)6, true);
Polygon polygon;
ConnEnd srcPt;
ConnEnd dstPt;
ConnEnd heConnPt;
PolyLine newRoute;
ShapeConnectionPin *connPin = NULL;
// shapeRef1
polygon = Polygon(4);
polygon.ps[0] = Point(450, 330);
polygon.ps[1] = Point(490, 330);
polygon.ps[2] = Point(490, 450);
polygon.ps[3] = Point(450, 450);
ShapeRef *shapeRef1 = new ShapeRef(router, polygon, 1);
connPin = new ShapeConnectionPin(shapeRef1, 1, 0, 0.333333, true, 10, (ConnDirFlags) 0);
connPin->setExclusive(false);
connPin = new ShapeConnectionPin(shapeRef1, 2, 0, 0.666667, true, 10, (ConnDirFlags) 0);
connPin->setExclusive(false);
connPin = new ShapeConnectionPin(shapeRef1, 3, 1, 0.5, true, 10, (ConnDirFlags) 0);
connPin->setExclusive(false);
connPin = new ShapeConnectionPin(shapeRef1, 4, 0.5, 0, true, 10, (ConnDirFlags) 0);
connPin->setExclusive(false);
// shapeRef8
polygon = Polygon(4);
polygon.ps[0] = Point(502, 237.5);
polygon.ps[1] = Point(502, 262.5);
polygon.ps[2] = Point(438, 262.5);
polygon.ps[3] = Point(438, 237.5);
ShapeRef *shapeRef8 = new ShapeRef(router, polygon, 8);
connPin = new ShapeConnectionPin(shapeRef8, 1, 0, 0.5, true, 1, (ConnDirFlags) 0);
connPin = new ShapeConnectionPin(shapeRef8, 2, 1, 0.5, true, 1, (ConnDirFlags) 0);
connPin = new ShapeConnectionPin(shapeRef8, 3, 0.5, 1, true, 1, (ConnDirFlags) 0);
connPin = new ShapeConnectionPin(shapeRef8, 4, 0.5, 0, true, 1, (ConnDirFlags) 0);
JunctionRef *junctionRef6 = new JunctionRef(router, Point(470, 300), 6);
/*
// This may be useful if junction pins are modified.
connPin = new ShapeConnectionPin(junctionRef6, 2147483646, (ConnDirFlags) 15);
*/
// connRef9
ConnRef *connRef9 = new ConnRef(router, 9);
srcPt = ConnEnd(junctionRef6);
connRef9->setSourceEndpoint(srcPt);
dstPt = ConnEnd(shapeRef8, 3);
connRef9->setDestEndpoint(dstPt);
connRef9->setRoutingType((ConnType)2);
#if 1
// connRef10 - WITH BUG
ConnRef *connRef10 = new ConnRef(router, 10);
srcPt = ConnEnd(junctionRef6);
connRef10->setSourceEndpoint(srcPt);
dstPt = ConnEnd(shapeRef1, 4);
connRef10->setDestEndpoint(dstPt);
connRef10->setRoutingType((ConnType)2);
#else
// connRef10 - WITHOUT BUG
ConnRef *connRef10 = new ConnRef(router, 10);
srcPt = ConnEnd(shapeRef1, 4);
connRef10->setSourceEndpoint(srcPt);
dstPt = ConnEnd(junctionRef6);
connRef10->setDestEndpoint(dstPt);
connRef10->setRoutingType((ConnType)2);
#endif
// router->deleteConnector(connRef5);
router->processTransaction();
ConnRef *mergedConn = junctionRef6->removeJunctionAndMergeConnectors();
router->processTransaction();
router->outputDiagram("output/removeJunctions01");
std::pair<ConnEnd, ConnEnd> ends = mergedConn->endpointConnEnds();
// Expected result: output images should be virtually identical.
// Result: An endpoint seems to be disconnected from shapeRef8.
bool isConnected = (ends.first.shape() == shapeRef8) || (ends.second.shape() == shapeRef8);
delete router;
return isConnected ? 0 : 1;
};
int main(void) {
Router *router = new Router(
PolyLineRouting | OrthogonalRouting);
router->setRoutingPenalty((PenaltyType)0, 50);
router->setRoutingPenalty((PenaltyType)1, 0);
router->setRoutingPenalty((PenaltyType)2, 200);
router->setRoutingPenalty((PenaltyType)3, 4000);
router->setRoutingPenalty((PenaltyType)4, 110);
router->setRoutingParameter(idealNudgingDistance, 25);
Polygon poly282634758(4);
poly282634758.ps[0] = Point(51360, 50215);
poly282634758.ps[1] = Point(51360, 50460);
poly282634758.ps[2] = Point(51075, 50460);
poly282634758.ps[3] = Point(51075, 50215);
new ShapeRef(router, poly282634758, 282634758);
Polygon poly69386928(4);
poly69386928.ps[0] = Point(51050, 50415);
poly69386928.ps[1] = Point(51050, 50735);
poly69386928.ps[2] = Point(50690, 50735);
poly69386928.ps[3] = Point(50690, 50415);
new ShapeRef(router, poly69386928, 69386928);
Polygon poly11958280(4);
poly11958280.ps[0] = Point(50460, 50490);
poly11958280.ps[1] = Point(50460, 50660);
poly11958280.ps[2] = Point(50290, 50660);
poly11958280.ps[3] = Point(50290, 50490);
new ShapeRef(router, poly11958280, 11958280);
Polygon poly50591298(4);
poly50591298.ps[0] = Point(51260, 50015);
poly50591298.ps[1] = Point(51260, 50185);
poly50591298.ps[2] = Point(51075, 50185);
poly50591298.ps[3] = Point(51075, 50015);
new ShapeRef(router, poly50591298, 50591298);
ConnRef *connRef355676284 = new ConnRef(router, 355676284);
ConnEnd srcPt355676284(Point(51040, 50575), 8);
connRef355676284->setSourceEndpoint(srcPt355676284);
ConnEnd dstPt355676284(Point(51085, 50300), 4);
connRef355676284->setDestEndpoint(dstPt355676284);
connRef355676284->setRoutingType((ConnType)2);
ConnRef *connRef33653259 = new ConnRef(router, 33653259);
ConnEnd srcPt33653259(Point(51040, 50650), 8);
connRef33653259->setSourceEndpoint(srcPt33653259);
ConnEnd dstPt33653259(Point(51085, 50375), 4);
connRef33653259->setDestEndpoint(dstPt33653259);
connRef33653259->setRoutingType((ConnType)2);
ConnRef *connRef421608980 = new ConnRef(router, 421608980);
ConnEnd srcPt421608980(Point(51040, 50500), 8);
connRef421608980->setSourceEndpoint(srcPt421608980);
ConnEnd dstPt421608980(Point(51085, 50100), 4);
connRef421608980->setDestEndpoint(dstPt421608980);
connRef421608980->setRoutingType((ConnType)2);
router->processTransaction();
router->outputDiagram("output/restrictedNudging");
bool overlap = router->existsOrthogonalTouchingPaths();
delete router;
return (overlap) ? 1 : 0;
};
