C++ Router::outputInstanceToSVG方法代码示例

int main(void) {
    Router *router = new Router(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, 105);
    router->setOrthogonalNudgeDistance(25);
    Rectangle rect478845150(Point(50695, 51070), Point(50705, 51080));
    JunctionRef *junctionRef478845150 = new JunctionRef(router, 
		    Point(50700, 51075), 478845150);
    
    Rectangle rect92712048(Point(51246, 50475), Point(51304, 50585));
    new ShapeRef(router, rect92712048, 92712048);
    Rectangle rect23127921(Point(50365, 50766), Point(50485, 50834));
    new ShapeRef(router, rect23127921, 23127921);
    Rectangle rect159957148(Point(51740, 50891), Point(51860, 50959));
    new ShapeRef(router, rect159957148, 159957148);
    Rectangle rect1350214(Point(50375, 51015), Point(50625, 51135));
    new ShapeRef(router, rect1350214, 1350214);
    Rectangle rect247197258(Point(50265, 51046), Point(50375, 51104));
    new ShapeRef(router, rect247197258, 247197258);
    Rectangle rect281096654(Point(50700, 50390), Point(51000, 50610));
    new ShapeRef(router, rect281096654, 281096654);
    ConnEnd srcPt342420237(Point(50425, 50800), 15);
    ConnEnd dstPt342420237(Point(50710, 50450), 4);
    new ConnRef(router, srcPt342420237, dstPt342420237, 342420237);
    ConnEnd srcPt352019675(Point(50990, 50500), 8);
    ConnEnd dstPt352019675(junctionRef478845150);
    //ConnEnd dstPt352019675(Point(50700, 51075), 15);
    new ConnRef(router, srcPt352019675, dstPt352019675, 352019675);
    ConnEnd srcPt42699400(junctionRef478845150);
    //ConnEnd srcPt42699400(Point(50700, 51075), 15);
    ConnEnd dstPt42699400(Point(50615, 51075), 8);
    new ConnRef(router, srcPt42699400, dstPt42699400, 42699400);
    ConnEnd srcPt94712625(Point(50710, 50550), 4);
    ConnEnd dstPt94712625(junctionRef478845150);
    //ConnEnd dstPt94712625(Point(50700, 51075), 15);
    new ConnRef(router, srcPt94712625, dstPt94712625, 94712625);
    
    ConnEnd srcPt92802970(Point(50990, 50450), 8);
    ConnEnd dstPt92802970(Point(51275, 50485), 1);
    ConnRef *conn = new ConnRef(router, srcPt92802970, dstPt92802970, 92802970);
    std::vector<Point> checkpoints;
    checkpoints.push_back(Point(50000, 50000));
    checkpoints.push_back(Point(50200, 50000));
    checkpoints.push_back(Point(50200, 50200));
    conn->setRoutingCheckpoints(checkpoints);
    
    ConnEnd srcPt716502036(Point(50710, 50500), 4);
    ConnEnd dstPt716502036(Point(51800, 50925), 15);
    new ConnRef(router, srcPt716502036, dstPt716502036, 716502036);
    router->processTransaction();
    router->outputInstanceToSVG("test-checkpoints01-1");
    router->moveJunction(junctionRef478845150, 585, 0);
    router->processTransaction();
    router->outputInstanceToSVG("test-checkpoints01-2");
    delete router;
    return 0;
};

int main(void) {
    Router *router = new Router(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, 105);
    router->setOrthogonalNudgeDistance(25);
    Rectangle rect478845150(Point(50695, 51070), Point(50705, 51080));
    ShapeRef *shapeRef478845150 = new ShapeRef(router, rect478845150, 478845150);
    ShapeConnectionPin *pin = new Avoid::ShapeConnectionPin(shapeRef478845150, 
	    Avoid::CONNECTIONPIN_CENTRE, Avoid::ATTACH_POS_CENTRE, 
	    Avoid::ATTACH_POS_CENTRE);
    pin->setExclusive(false);
    
    router->addShape(shapeRef478845150);
    Rectangle rect92712048(Point(51246, 50475), Point(51304, 50585));
    ShapeRef *shapeRef92712048 = new ShapeRef(router, rect92712048, 92712048);
    router->addShape(shapeRef92712048);
    Rectangle rect23127921(Point(50365, 50766), Point(50485, 50834));
    ShapeRef *shapeRef23127921 = new ShapeRef(router, rect23127921, 23127921);
    router->addShape(shapeRef23127921);
    Rectangle rect159957148(Point(51740, 50891), Point(51860, 50959));
    ShapeRef *shapeRef159957148 = new ShapeRef(router, rect159957148, 159957148);
    router->addShape(shapeRef159957148);
    Rectangle rect1350214(Point(50375, 51015), Point(50625, 51135));
    ShapeRef *shapeRef1350214 = new ShapeRef(router, rect1350214, 1350214);
    router->addShape(shapeRef1350214);
    Rectangle rect247197258(Point(50265, 51046), Point(50375, 51104));
    ShapeRef *shapeRef247197258 = new ShapeRef(router, rect247197258, 247197258);
    router->addShape(shapeRef247197258);
    Rectangle rect281096654(Point(50700, 50390), Point(51000, 50610));
    ShapeRef *shapeRef281096654 = new ShapeRef(router, rect281096654, 281096654);
    router->addShape(shapeRef281096654);
    ConnEnd srcPt342420237(Point(50425, 50800), 15);
    ConnEnd dstPt342420237(Point(50710, 50450), 4);
    new ConnRef(router, srcPt342420237, dstPt342420237, 342420237);
    ConnEnd srcPt352019675(Point(50990, 50500), 8);
    ConnEnd dstPt352019675(shapeRef478845150, Avoid::CONNECTIONPIN_CENTRE);
    //ConnEnd dstPt352019675(Point(50700, 51075), 15);
    new ConnRef(router, srcPt352019675, dstPt352019675, 352019675);
    ConnEnd srcPt42699400(shapeRef478845150, Avoid::CONNECTIONPIN_CENTRE);
    //ConnEnd srcPt42699400(Point(50700, 51075), 15);
    ConnEnd dstPt42699400(Point(50615, 51075), 8);
    new ConnRef(router, srcPt42699400, dstPt42699400, 42699400);
    ConnEnd srcPt94712625(Point(50710, 50550), 4);
    ConnEnd dstPt94712625(shapeRef478845150, Avoid::CONNECTIONPIN_CENTRE);
    //ConnEnd dstPt94712625(Point(50700, 51075), 15);
    new ConnRef(router, srcPt94712625, dstPt94712625, 94712625);
    ConnEnd srcPt92802970(Point(50990, 50450), 8);
    ConnEnd dstPt92802970(Point(51275, 50485), 1);
    new ConnRef(router, srcPt92802970, dstPt92802970, 92802970);
    ConnEnd srcPt716502036(Point(50710, 50500), 4);
    ConnEnd dstPt716502036(Point(51800, 50925), 15);
    new ConnRef(router, srcPt716502036, dstPt716502036, 716502036);
    router->processTransaction();
    router->outputInstanceToSVG("test-junction01");
    delete router;
    return 0;
};

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, 110);
    router->setRoutingParameter(idealNudgingDistance, 25);

    Polygon poly421433292(4);
    poly421433292.ps[0] = Point(51335, 50215);
    poly421433292.ps[1] = Point(51335, 50385);
    poly421433292.ps[2] = Point(51065, 50385);
    poly421433292.ps[3] = Point(51065, 50215);
    new ShapeRef(router, poly421433292, 421433292);

    Polygon poly174734866(4);
    poly174734866.ps[0] = Point(51335, 50490);
    poly174734866.ps[1] = Point(51335, 50660);
    poly174734866.ps[2] = Point(51065, 50660);
    poly174734866.ps[3] = Point(51065, 50490);
    new ShapeRef(router, poly174734866, 174734866);

    Polygon poly564884274(4);
    poly564884274.ps[0] = Point(50635, 50500);
    poly564884274.ps[1] = Point(50635, 50583);
    poly564884274.ps[2] = Point(50515, 50583);
    poly564884274.ps[3] = Point(50515, 50500);
    new ShapeRef(router, poly564884274, 564884274);

    ConnRef *connRef103176525 = new ConnRef(router, 103176525);
    ConnEnd srcPt103176525(Point(51085, 50550), 4);
    connRef103176525->setSourceEndpoint(srcPt103176525);
    ConnEnd dstPt103176525(Point(50575, 50510), 1);
    connRef103176525->setDestEndpoint(dstPt103176525);
    connRef103176525->setRoutingType((ConnType)2);

    ConnRef *connRef223495632 = new ConnRef(router, 223495632);
    ConnEnd srcPt223495632(Point(51085, 50325), 4);
    connRef223495632->setSourceEndpoint(srcPt223495632);
    ConnEnd dstPt223495632(Point(50575, 50550), 14);
    connRef223495632->setDestEndpoint(dstPt223495632);
    connRef223495632->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("output/inlineoverlap03");
    bool overlap = router->existsOrthogonalFixedSegmentOverlap();
    delete router;
    return (overlap) ? 1 : 0;
};

int main(void) {
    Router *router = new Router(OrthogonalRouting);
    router->setRoutingPenalty((Avoid::PenaltyType)0, 50);
    router->setRoutingPenalty((Avoid::PenaltyType)1, 0);
    router->setRoutingPenalty((Avoid::PenaltyType)2, 200);
    router->setRoutingPenalty((Avoid::PenaltyType)3, 4000);
    router->setRoutingPenalty((Avoid::PenaltyType)4, 110);
    router->setRoutingParameter(idealNudgingDistance, 25);
    Rectangle rect548374163(Point(51900, 50400), Point(52300, 50900));
    new ShapeRef(router, rect548374163, 548374163);
    Rectangle rect901116812(Point(51131, 49750), Point(51531, 50100));
    new ShapeRef(router, rect901116812, 901116812);
    Rectangle rect335855988(Point(51125, 50175), Point(51525, 50900));
    new ShapeRef(router, rect335855988, 335855988);
    Rectangle rect448725420(Point(52375, 50750), Point(52575, 50900));
    new ShapeRef(router, rect448725420, 448725420);
    Rectangle rect74263573(Point(51900, 49750), Point(52300, 50100));
    new ShapeRef(router, rect74263573, 74263573);
    ConnEnd srcPt463223880(Point(51500, 50275), 8);
    ConnEnd dstPt463223880(Point(51150, 50275), 4);
    ConnEnd srcPt144520410(Point(51150, 49850), 4);
    ConnEnd dstPt144520410(Point(51500, 50350), 8);
    ConnEnd srcPt45398340(Point(52400, 50825), 4);
    ConnEnd dstPt45398340(Point(51500, 49925), 8);
    ConnEnd srcPt29344262(Point(51150, 50500), 4);
    ConnEnd dstPt29344262(Point(51925, 50000), 4);
    new ConnRef(router, srcPt29344262, dstPt29344262, 29344262);
    new ConnRef(router, srcPt45398340, dstPt45398340, 45398340);
    new ConnRef(router, srcPt144520410, dstPt144520410, 144520410);
    new ConnRef(router, srcPt463223880, dstPt463223880, 463223880);
    router->processTransaction();
    router->outputInstanceToSVG("output/nudgeintobug");
    bool overlap = router->existsOrthogonalFixedSegmentOverlap();
    bool touching = router->existsOrthogonalTouchingPaths();
    delete router;
    return (overlap || touching) ? 1 : 0;
};

int main(void) {
    Router *router = new Router(OrthogonalRouting);
    router->setRoutingPenalty(segmentPenalty, 50);
    router->setOrthogonalNudgeDistance(10);
    Rectangle rect47(Point(51145, 50195), Point(51145+360, 50195+685));
    new ShapeRef(router, rect47);
    Rectangle rect46(Point(51920, 49770), Point(51920+360, 49770+310));
    new ShapeRef(router, rect46);
    Rectangle rect45(Point(51151, 49770), Point(51151+360, 49770+310));
    new ShapeRef(router, rect45);
    ConnEnd srcPt53(Point(51150,49850), 4);
    ConnEnd dstPt53(Point(51500,50350), 8);
    new ConnRef(router, srcPt53, dstPt53);
    ConnEnd srcPt52(Point(52275,49850), 8);
    ConnEnd dstPt52(Point(51150,49925), 4);
    new ConnRef(router, srcPt52, dstPt52);
    ConnEnd srcPt6(Point(51150,50500), 4);
    ConnEnd dstPt6(Point(51925,50000), 4);
    new ConnRef(router, srcPt6, dstPt6, 6);
    router->processTransaction();
    router->outputInstanceToSVG("test-infinity");
    delete router;
    return 0;
};

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, 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->outputInstanceToSVG("output/orthordering-02");
    
    int crossings = router->existsCrossings();

    delete router;
    return (crossings > 0) ? 1 : 0;
};

//.........这里部分代码省略.........
    router->setRoutingOption((RoutingOption)2, true);
    router->setRoutingOption(improveHyperedgeRoutesMovingJunctions, false);
    router->setRoutingOption(improveHyperedgeRoutesMovingAddingAndDeletingJunctions, true);
    router->setRoutingParameter(idealNudgingDistance, 25);

    Polygon poly2(4);
    poly2.ps[0] = Point(50354, 50975);
    poly2.ps[1] = Point(50354, 51060);
    poly2.ps[2] = Point(50296, 51060);
    poly2.ps[3] = Point(50296, 50975);
    ShapeRef *shapeRef2 = new ShapeRef(router, poly2, 2);
    new ShapeConnectionPin(shapeRef2, 1, 0.5, 1, true, 10, (ConnDirFlags) 1);

    Polygon poly39761567(4);
    poly39761567.ps[0] = Point(50754, 50975);
    poly39761567.ps[1] = Point(50754, 51060);
    poly39761567.ps[2] = Point(50696, 51060);
    poly39761567.ps[3] = Point(50696, 50975);
    ShapeRef *shapeRef39761567 = new ShapeRef(router, poly39761567, 39761567);
    new ShapeConnectionPin(shapeRef39761567, 1, 0.5, 0, true, 10, (ConnDirFlags) 1);

    Polygon poly115776716(4);
    poly115776716.ps[0] = Point(51504, 50975);
    poly115776716.ps[1] = Point(51504, 51060);
    poly115776716.ps[2] = Point(51446, 51060);
    poly115776716.ps[3] = Point(51446, 50975);
    ShapeRef *shapeRef115776716 = new ShapeRef(router, poly115776716, 115776716);
    new ShapeConnectionPin(shapeRef115776716, 1, 0.5, 0, true, 10, (ConnDirFlags) 1);

    Polygon poly238475293(4);
    poly238475293.ps[0] = Point(50554, 50975);
    poly238475293.ps[1] = Point(50554, 51060);
    poly238475293.ps[2] = Point(50496, 51060);
    poly238475293.ps[3] = Point(50496, 50975);
    ShapeRef *shapeRef238475293 = new ShapeRef(router, poly238475293, 238475293);
    new ShapeConnectionPin(shapeRef238475293, 1, 0.5, 0, true, 10, (ConnDirFlags) 1);

    Polygon poly430971008(4);
    poly430971008.ps[0] = Point(51004, 50975);
    poly430971008.ps[1] = Point(51004, 51060);
    poly430971008.ps[2] = Point(50946, 51060);
    poly430971008.ps[3] = Point(50946, 50975);
    ShapeRef *shapeRef430971008 = new ShapeRef(router, poly430971008, 430971008);
    new ShapeConnectionPin(shapeRef430971008, 1, 0.5, 0, true, 10, (ConnDirFlags) 1);

    JunctionRef *junctionRef513246008 = new JunctionRef(router, Point(50925, 50700), 513246008);
    /*
    // This may be useful if junction pins are modified.
    new ShapeConnectionPin(junctionRef513246008, 2147483646, (ConnDirFlags) 15);
    */
    JunctionRef *junctionRef4 = new JunctionRef(router, Point(50725, 50725), 4);

    ConnRef *connRef3 = new ConnRef(router, 3);
    ConnEnd srcPt3(shapeRef2, 1);
    connRef3->setSourceEndpoint(srcPt3);
    ConnEnd dstPt3(junctionRef513246008);
    connRef3->setDestEndpoint(dstPt3);
    connRef3->setRoutingType((ConnType)2);
    
    ConnRef *connRef5 = new ConnRef(router, 5);
    ConnEnd srcPt5(junctionRef4);
    connRef5->setSourceEndpoint(srcPt5);
    ConnEnd dstPt5(junctionRef513246008);
    connRef5->setDestEndpoint(dstPt5);
    connRef5->setRoutingType((ConnType)2);

    ConnRef *connRef513246009 = new ConnRef(router, 513246009);
    ConnEnd srcPt513246009(shapeRef39761567, 1);
    connRef513246009->setSourceEndpoint(srcPt513246009);
    ConnEnd dstPt513246009(junctionRef4);
    connRef513246009->setDestEndpoint(dstPt513246009);
    connRef513246009->setRoutingType((ConnType)2);

    ConnRef *connRef513246010 = new ConnRef(router, 513246010);
    ConnEnd srcPt513246010(junctionRef513246008);
    connRef513246010->setSourceEndpoint(srcPt513246010);
    ConnEnd dstPt513246010(shapeRef430971008, 1);
    connRef513246010->setDestEndpoint(dstPt513246010);
    connRef513246010->setRoutingType((ConnType)2);

    ConnRef *connRef513246011 = new ConnRef(router, 513246011);
    ConnEnd srcPt513246011(junctionRef4);
    connRef513246011->setSourceEndpoint(srcPt513246011);
    ConnEnd dstPt513246011(shapeRef238475293, 1);
    connRef513246011->setDestEndpoint(dstPt513246011);
    connRef513246011->setRoutingType((ConnType)2);

    ConnRef *connRef513246012 = new ConnRef(router, 513246012);
    ConnEnd srcPt513246012(shapeRef115776716, 1);
    connRef513246012->setSourceEndpoint(srcPt513246012);
    ConnEnd dstPt513246012(junctionRef513246008);
    connRef513246012->setDestEndpoint(dstPt513246012);
    connRef513246012->setRoutingType((ConnType)2);
    router->processTransaction();
    router->outputInstanceToSVG("output/improveHyperedge04");

    bool overlaps = router->existsOrthogonalSegmentOverlap(true);
    delete router;
    return (overlaps) ? 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->setOrthogonalNudgeDistance(25);

    Polygon poly186982048(4);
    poly186982048.ps[0] = Point(52660, 50490);
    poly186982048.ps[1] = Point(52660, 50960);
    poly186982048.ps[2] = Point(52100, 50960);
    poly186982048.ps[3] = Point(52100, 50490);
    ShapeRef *shapeRef186982048 = new ShapeRef(router, poly186982048, 186982048);
    router->addShape(shapeRef186982048);

    Polygon poly193989760(4);
    poly193989760.ps[0] = Point(51850, 50665);
    poly193989760.ps[1] = Point(51850, 50835);
    poly193989760.ps[2] = Point(51590, 50835);
    poly193989760.ps[3] = Point(51590, 50665);
    ShapeRef *shapeRef193989760 = new ShapeRef(router, poly193989760, 193989760);
    router->addShape(shapeRef193989760);

    Polygon poly276825384(4);
    poly276825384.ps[0] = Point(51825, 51040);
    poly276825384.ps[1] = Point(51825, 51210);
    poly276825384.ps[2] = Point(51565, 51210);
    poly276825384.ps[3] = Point(51565, 51040);
    ShapeRef *shapeRef276825384 = new ShapeRef(router, poly276825384, 276825384);
    router->addShape(shapeRef276825384);

    Polygon poly190150804(4);
    poly190150804.ps[0] = Point(50460, 51340);
    poly190150804.ps[1] = Point(50460, 51510);
    poly190150804.ps[2] = Point(50290, 51510);
    poly190150804.ps[3] = Point(50290, 51340);
    ShapeRef *shapeRef190150804 = new ShapeRef(router, poly190150804, 190150804);
    router->addShape(shapeRef190150804);

    ConnRef *connRef562170592 = new ConnRef(router, 562170592);
    ConnEnd srcPt562170592(Point(52110, 50800), 4);
    connRef562170592->setSourceEndpoint(srcPt562170592);
    ConnEnd dstPt562170592(Point(51815, 51100), 8);
    connRef562170592->setDestEndpoint(dstPt562170592);
    connRef562170592->setRoutingType((ConnType)2);

    ConnRef *connRef171593006 = new ConnRef(router, 171593006);
    ConnEnd srcPt171593006(Point(52110, 50750), 4);
    connRef171593006->setSourceEndpoint(srcPt171593006);
    ConnEnd dstPt171593006(Point(51840, 50725), 8);
    connRef171593006->setDestEndpoint(dstPt171593006);
    connRef171593006->setRoutingType((ConnType)2);

    ConnRef *connRef172593160 = new ConnRef(router, 172593160);
    ConnEnd srcPt172593160(Point(51815, 51150), 8);
    connRef172593160->setSourceEndpoint(srcPt172593160);
    ConnEnd dstPt172593160(Point(52110, 50900), 4);
    connRef172593160->setDestEndpoint(dstPt172593160);
    connRef172593160->setRoutingType((ConnType)2);

    ConnRef *connRef116944564 = new ConnRef(router, 116944564);
    ConnEnd srcPt116944564(Point(51840, 50775), 8);
    connRef116944564->setSourceEndpoint(srcPt116944564);
    ConnEnd dstPt116944564(Point(52110, 50850), 4);
    connRef116944564->setDestEndpoint(dstPt116944564);
    connRef116944564->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("test-inlineoverlap-07");
    delete router;
    return 0;
};

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, 110);
    router->setOrthogonalNudgeDistance(25);

    Polygon poly231469760(4);
    poly231469760.ps[0] = Point(6385, 9390);
    poly231469760.ps[1] = Point(6385, 9560);
    poly231469760.ps[2] = Point(6200, 9560);
    poly231469760.ps[3] = Point(6200, 9390);
    ShapeRef *shapeRef231469760 = new ShapeRef(router, poly231469760, 231469760);
    router->addShape(shapeRef231469760);

    Polygon poly7136376(4);
    poly7136376.ps[0] = Point(6560, 9290);
    poly7136376.ps[1] = Point(6560, 9460);
    poly7136376.ps[2] = Point(6375, 9460);
    poly7136376.ps[3] = Point(6375, 9290);
    ShapeRef *shapeRef7136376 = new ShapeRef(router, poly7136376, 7136376);
    router->addShape(shapeRef7136376);

    Polygon poly215821749(4);
    poly215821749.ps[0] = Point(6510, 9540);
    poly215821749.ps[1] = Point(6510, 9710);
    poly215821749.ps[2] = Point(6325, 9710);
    poly215821749.ps[3] = Point(6325, 9540);
    ShapeRef *shapeRef215821749 = new ShapeRef(router, poly215821749, 215821749);
    router->addShape(shapeRef215821749);

    Polygon poly83086994(4);
    poly83086994.ps[0] = Point(5925, 9240);
    poly83086994.ps[1] = Point(5925, 10085);
    poly83086994.ps[2] = Point(5575, 10085);
    poly83086994.ps[3] = Point(5575, 9240);
    ShapeRef *shapeRef83086994 = new ShapeRef(router, poly83086994, 83086994);
    router->addShape(shapeRef83086994);

    ConnRef *connRef292408794 = new ConnRef(router, 292408794);
    ConnEnd srcPt292408794(Point(5915, 9625), 8);
    connRef292408794->setSourceEndpoint(srcPt292408794);
    ConnEnd dstPt292408794(Point(6210, 9475), 4);
    connRef292408794->setDestEndpoint(dstPt292408794);
    connRef292408794->setRoutingType((ConnType)2);

    ConnRef *connRef40917776 = new ConnRef(router, 40917776);
    ConnEnd srcPt40917776(Point(5915, 9550), 8);
    connRef40917776->setSourceEndpoint(srcPt40917776);
    ConnEnd dstPt40917776(Point(6385, 9375), 4);
    connRef40917776->setDestEndpoint(dstPt40917776);
    connRef40917776->setRoutingType((ConnType)2);

    ConnRef *connRef629564142 = new ConnRef(router, 629564142);
    ConnEnd srcPt629564142(Point(5915, 9475), 8);
    connRef629564142->setSourceEndpoint(srcPt629564142);
    ConnEnd dstPt629564142(Point(6335, 9625), 4);
    connRef629564142->setDestEndpoint(dstPt629564142);
    connRef629564142->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("test-inlineoverlap-05");
    bool overlap = router->existsOrthogonalPathOverlap();
    delete router;
    return (overlap) ? 1 : 0;
};

int main(void) {
    Router *router = new Router(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->setOrthogonalNudgeDistance(4);

    Polygon poly1(4);
    poly1.ps[0] = Point(52, 188);
    poly1.ps[1] = Point(52, 292);
    poly1.ps[2] = Point(-52, 292);
    poly1.ps[3] = Point(-52, 188);
    ShapeRef *shapeRef1 = new ShapeRef(router, poly1, 1);
    router->addShape(shapeRef1);
    new ShapeConnectionPin(shapeRef1, 544, 0.5, 0.5, 10, (ConnDirFlags) 0);

    Polygon poly2(4);
    poly2.ps[0] = Point(52, -52);
    poly2.ps[1] = Point(52, 52);
    poly2.ps[2] = Point(-52, 52);
    poly2.ps[3] = Point(-52, -52);
    ShapeRef *shapeRef2 = new ShapeRef(router, poly2, 2);
    router->addShape(shapeRef2);
    new ShapeConnectionPin(shapeRef2, 544, 0.5, 0.5, 10, (ConnDirFlags) 0);

    Polygon poly3(4);
    poly3.ps[0] = Point(52, 428);
    poly3.ps[1] = Point(52, 532);
    poly3.ps[2] = Point(-52, 532);
    poly3.ps[3] = Point(-52, 428);
    ShapeRef *shapeRef3 = new ShapeRef(router, poly3, 3);
    router->addShape(shapeRef3);
    new ShapeConnectionPin(shapeRef3, 544, 0.5, 0.5, 10, (ConnDirFlags) 0);

    Polygon poly4(4);
    poly4.ps[0] = Point(52, 68);
    poly4.ps[1] = Point(52, 172);
    poly4.ps[2] = Point(-52, 172);
    poly4.ps[3] = Point(-52, 68);
    ShapeRef *shapeRef4 = new ShapeRef(router, poly4, 4);
    router->addShape(shapeRef4);
    new ShapeConnectionPin(shapeRef4, 544, 0.5, 0.5, 10, (ConnDirFlags) 0);

    Polygon poly5(4);
    poly5.ps[0] = Point(52, 308);
    poly5.ps[1] = Point(52, 412);
    poly5.ps[2] = Point(-52, 412);
    poly5.ps[3] = Point(-52, 308);
    ShapeRef *shapeRef5 = new ShapeRef(router, poly5, 5);
    router->addShape(shapeRef5);
    new ShapeConnectionPin(shapeRef5, 544, 0.5, 0.5, 10, (ConnDirFlags) 0);

    ConnRef *connRef6 = new ConnRef(router, 6);
    ConnEnd srcPt6(shapeRef2, 544);
    connRef6->setSourceEndpoint(srcPt6);
    ConnEnd dstPt6(shapeRef5, 544);
    connRef6->setDestEndpoint(dstPt6);
    connRef6->setRoutingType((ConnType)2);

    ConnRef *connRef7 = new ConnRef(router, 7);
    ConnEnd srcPt7(shapeRef5, 544);
    connRef7->setSourceEndpoint(srcPt7);
    ConnEnd dstPt7(shapeRef4, 544);
    connRef7->setDestEndpoint(dstPt7);
    connRef7->setRoutingType((ConnType)2);

    ConnRef *connRef8 = new ConnRef(router, 8);
    ConnEnd srcPt8(shapeRef1, 544);
    connRef8->setSourceEndpoint(srcPt8);
    ConnEnd dstPt8(shapeRef5, 544);
    connRef8->setDestEndpoint(dstPt8);
    connRef8->setRoutingType((ConnType)2);

    ConnRef *connRef9 = new ConnRef(router, 9);
    ConnEnd srcPt9(shapeRef2, 544);
    connRef9->setSourceEndpoint(srcPt9);
    ConnEnd dstPt9(shapeRef3, 544);
    connRef9->setDestEndpoint(dstPt9);
    connRef9->setRoutingType((ConnType)2);

    ConnRef *connRef10 = new ConnRef(router, 10);
    ConnEnd srcPt10(shapeRef3, 544);
    connRef10->setSourceEndpoint(srcPt10);
    ConnEnd dstPt10(shapeRef4, 544);
    connRef10->setDestEndpoint(dstPt10);
    connRef10->setRoutingType((ConnType)2);

    ConnRef *connRef11 = new ConnRef(router, 11);
    ConnEnd srcPt11(shapeRef1, 544);
    connRef11->setSourceEndpoint(srcPt11);
    ConnEnd dstPt11(shapeRef3, 544);
    connRef11->setDestEndpoint(dstPt11);
    connRef11->setRoutingType((ConnType)2);
    
    router->processTransaction();
    router->outputInstanceToSVG("test-inlineShapes");
    delete router;
    return 0;
//.........这里部分代码省略.........

//.........这里部分代码省略.........
    ConnEnd dstPt34178450(Point(51010, 51000), 4);
    connRef34178450->setDestEndpoint(dstPt34178450);
    connRef34178450->setRoutingType((ConnType)2);

    ConnRef *connRef7982176 = new ConnRef(router, 7982176);
    ConnEnd srcPt7982176(Point(50675, 51260), 1);
    connRef7982176->setSourceEndpoint(srcPt7982176);
    ConnEnd dstPt7982176(shapeRef219926511, 2147483646);
    connRef7982176->setDestEndpoint(dstPt7982176);
    connRef7982176->setRoutingType((ConnType)2);

    ConnRef *connRef197177982 = new ConnRef(router, 197177982);
    ConnEnd srcPt197177982(Point(50750, 51250), 15);
    connRef197177982->setSourceEndpoint(srcPt197177982);
    ConnEnd dstPt197177982(Point(50750, 51260), 1);
    connRef197177982->setDestEndpoint(dstPt197177982);
    connRef197177982->setRoutingType((ConnType)2);

    ConnRef *connRef398066432 = new ConnRef(router, 398066432);
    ConnEnd srcPt398066432(shapeRef219926511, 2147483646);
    connRef398066432->setSourceEndpoint(srcPt398066432);
    ConnEnd dstPt398066432(Point(50850, 51260), 1);
    connRef398066432->setDestEndpoint(dstPt398066432);
    connRef398066432->setRoutingType((ConnType)2);

    ConnRef *connRef314512308 = new ConnRef(router, 314512308);
    ConnEnd srcPt314512308(Point(51000, 51235), 1);
    connRef314512308->setSourceEndpoint(srcPt314512308);
    ConnEnd dstPt314512308(shapeRef171026375, 2147483646);
    connRef314512308->setDestEndpoint(dstPt314512308);
    connRef314512308->setRoutingType((ConnType)2);

    ConnRef *connRef182776308 = new ConnRef(router, 182776308);
    ConnEnd srcPt182776308(Point(51075, 51225), 15);
    connRef182776308->setSourceEndpoint(srcPt182776308);
    ConnEnd dstPt182776308(Point(51075, 51165), 2);
    connRef182776308->setDestEndpoint(dstPt182776308);
    connRef182776308->setRoutingType((ConnType)2);

    ConnRef *connRef96504835 = new ConnRef(router, 96504835);
    ConnEnd srcPt96504835(Point(51150, 51235), 1);
    connRef96504835->setSourceEndpoint(srcPt96504835);
    ConnEnd dstPt96504835(shapeRef171026375, 2147483646);
    connRef96504835->setDestEndpoint(dstPt96504835);
    connRef96504835->setRoutingType((ConnType)2);

    ConnRef *connRef118099300 = new ConnRef(router, 118099300);
    ConnEnd srcPt118099300(Point(51425, 51210), 1);
    connRef118099300->setSourceEndpoint(srcPt118099300);
    ConnEnd dstPt118099300(shapeRef223927132, 2147483646);
    connRef118099300->setDestEndpoint(dstPt118099300);
    connRef118099300->setRoutingType((ConnType)2);

    ConnRef *connRef176080410 = new ConnRef(router, 176080410);
    ConnEnd srcPt176080410(shapeRef223927132, 2147483646);
    connRef176080410->setSourceEndpoint(srcPt176080410);
    ConnEnd dstPt176080410(Point(51575, 51210), 1);
    connRef176080410->setDestEndpoint(dstPt176080410);
    connRef176080410->setRoutingType((ConnType)2);

    ConnRef *connRef426666001 = new ConnRef(router, 426666001);
    ConnEnd srcPt426666001(Point(51500, 51210), 1);
    connRef426666001->setSourceEndpoint(srcPt426666001);
    ConnEnd dstPt426666001(Point(51500, 51200), 15);
    connRef426666001->setDestEndpoint(dstPt426666001);
    connRef426666001->setRoutingType((ConnType)2);

    ConnRef *connRef795762792 = new ConnRef(router, 795762792);
    ConnEnd srcPt795762792(Point(51650, 51210), 1);
    connRef795762792->setSourceEndpoint(srcPt795762792);
    ConnEnd dstPt795762792(shapeRef223927132, 2147483646);
    connRef795762792->setDestEndpoint(dstPt795762792);
    connRef795762792->setRoutingType((ConnType)2);

    ConnRef *connRef467016913 = new ConnRef(router, 467016913);
    ConnEnd srcPt467016913(shapeRef265539540, 2147483646);
    connRef467016913->setSourceEndpoint(srcPt467016913);
    ConnEnd dstPt467016913(Point(51575, 51010), 1);
    connRef467016913->setDestEndpoint(dstPt467016913);
    connRef467016913->setRoutingType((ConnType)2);

    ConnRef *connRef45740440 = new ConnRef(router, 45740440);
    ConnEnd srcPt45740440(Point(51835, 50975), 4);
    connRef45740440->setSourceEndpoint(srcPt45740440);
    ConnEnd dstPt45740440(shapeRef265539540, 2147483646);
    connRef45740440->setDestEndpoint(dstPt45740440);
    connRef45740440->setRoutingType((ConnType)2);

    ConnRef *connRef985644192 = new ConnRef(router, 985644192);
    ConnEnd srcPt985644192(Point(51515, 50975), 8);
    connRef985644192->setSourceEndpoint(srcPt985644192);
    ConnEnd dstPt985644192(shapeRef265539540, 2147483646);
    connRef985644192->setDestEndpoint(dstPt985644192);
    connRef985644192->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("test-connectionpin03");
    delete router;
    return 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->setOrthogonalNudgeDistance(25);

    double buffer = 4;
    Polygon poly342721632(4);
    poly342721632.ps[0] = Point(51910, 50946);
    poly342721632.ps[1] = Point(51910, 51004);
    poly342721632.ps[2] = Point(51825, 51004);
    poly342721632.ps[3] = Point(51825, 50946);
    ShapeRef *shapeRef342721632 = new ShapeRef(router, poly342721632, 342721632);
    new ShapeConnectionPin(shapeRef342721632, 1, 
            ATTACH_POS_LEFT, ATTACH_POS_CENTRE, buffer, ConnDirLeft);

    Polygon poly807558175(4);
    poly807558175.ps[0] = Point(51604, 51000);
    poly807558175.ps[1] = Point(51604, 51085);
    poly807558175.ps[2] = Point(51546, 51085);
    poly807558175.ps[3] = Point(51546, 51000);
    ShapeRef *shapeRef807558175 = new ShapeRef(router, poly807558175, 807558175);
    new ShapeConnectionPin(shapeRef807558175, 1, 
	    ATTACH_POS_CENTRE, ATTACH_POS_TOP, buffer, ConnDirNone);

    Polygon poly404900496(4);
    poly404900496.ps[0] = Point(51525, 50946);
    poly404900496.ps[1] = Point(51525, 51004);
    poly404900496.ps[2] = Point(51440, 51004);
    poly404900496.ps[3] = Point(51440, 50946);
    ShapeRef *shapeRef404900496 = new ShapeRef(router, poly404900496, 404900496);
    new ShapeConnectionPin(shapeRef404900496, 1, 
	    ATTACH_POS_RIGHT, ATTACH_POS_CENTRE, buffer, (ConnDirFlags) 8);

    JunctionRef *junctionRef265539540 = new JunctionRef(router, Point(51625, 50950), 265539540);

    ConnRef *connRef985644192 = new ConnRef(router, 985644192);
    ConnEnd srcPt985644192(shapeRef404900496, 1);
    connRef985644192->setSourceEndpoint(srcPt985644192);
    ConnEnd dstPt985644192(junctionRef265539540);
    connRef985644192->setDestEndpoint(dstPt985644192);
    connRef985644192->setRoutingType((ConnType)2);

    ConnRef *connRef467016913 = new ConnRef(router, 467016913);
    ConnEnd srcPt467016913(junctionRef265539540);
    connRef467016913->setSourceEndpoint(srcPt467016913);
    ConnEnd dstPt467016913(shapeRef807558175, 1);
    connRef467016913->setDestEndpoint(dstPt467016913);
    connRef467016913->setRoutingType((ConnType)2);

    ConnRef *connRef45740440 = new ConnRef(router, 45740440);
    ConnEnd srcPt45740440(shapeRef342721632, 1);
    connRef45740440->setSourceEndpoint(srcPt45740440);
    ConnEnd dstPt45740440(junctionRef265539540);
    connRef45740440->setDestEndpoint(dstPt45740440);
    connRef45740440->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("test-node1");
    delete router;
    return 0;
};

//.........这里部分代码省略.........
    poly134604636.ps[3] = Point(29675, 26720);
    new ShapeRef(router, poly134604636, 134604636);
    
    Polygon poly14353632(4);
    poly14353632.ps[0] = Point(29600, 26590);
    poly14353632.ps[1] = Point(29600, 27660);
    poly14353632.ps[2] = Point(28440, 27660);
    poly14353632.ps[3] = Point(28440, 26590);
    new ShapeRef(router, poly14353632, 14353632);
    
    ConnRef *connRef70269732 = new ConnRef(router, 70269732);
    ConnEnd srcPt70269732(Point(29590, 26700), 8);
    connRef70269732->setSourceEndpoint(srcPt70269732);
    ConnEnd dstPt70269732(Point(29915, 26750), 8);
    connRef70269732->setDestEndpoint(dstPt70269732);
    connRef70269732->setRoutingType((ConnType)2);

    ConnRef *connRef371572709 = new ConnRef(router, 371572709);
    ConnEnd srcPt371572709(Point(29590, 26800), 8);
    connRef371572709->setSourceEndpoint(srcPt371572709);
    ConnEnd dstPt371572709(Point(29915, 26850), 8);
    connRef371572709->setDestEndpoint(dstPt371572709);
    connRef371572709->setRoutingType((ConnType)2);

    ConnRef *connRef876797766 = new ConnRef(router, 876797766);
    ConnEnd srcPt876797766(Point(29590, 26900), 8);
    connRef876797766->setSourceEndpoint(srcPt876797766);
    ConnEnd dstPt876797766(Point(29940, 26950), 8);
    connRef876797766->setDestEndpoint(dstPt876797766);
    connRef876797766->setRoutingType((ConnType)2);

    ConnRef *connRef134423590 = new ConnRef(router, 134423590);
    ConnEnd srcPt134423590(Point(29590, 27000), 8);
    connRef134423590->setSourceEndpoint(srcPt134423590);
    ConnEnd dstPt134423590(Point(29940, 27050), 8);
    connRef134423590->setDestEndpoint(dstPt134423590);
    connRef134423590->setRoutingType((ConnType)2);

    ConnRef *connRef872586669 = new ConnRef(router, 872586669);
    ConnEnd srcPt872586669(Point(29590, 27100), 8);
    connRef872586669->setSourceEndpoint(srcPt872586669);
    ConnEnd dstPt872586669(Point(29940, 27150), 8);
    connRef872586669->setDestEndpoint(dstPt872586669);
    connRef872586669->setRoutingType((ConnType)2);

    ConnRef *connRef23601612 = new ConnRef(router, 23601612);
    ConnEnd srcPt23601612(Point(29590, 27200), 8);
    connRef23601612->setSourceEndpoint(srcPt23601612);
    ConnEnd dstPt23601612(Point(29940, 27250), 8);
    connRef23601612->setDestEndpoint(dstPt23601612);
    connRef23601612->setRoutingType((ConnType)2);

    ConnRef *connRef737483980 = new ConnRef(router, 737483980);
    ConnEnd srcPt737483980(Point(29685, 26750), 4);
    connRef737483980->setSourceEndpoint(srcPt737483980);
    ConnEnd dstPt737483980(Point(29590, 26650), 8);
    connRef737483980->setDestEndpoint(dstPt737483980);
    connRef737483980->setRoutingType((ConnType)2);

    ConnRef *connRef410784855 = new ConnRef(router, 410784855);
    ConnEnd srcPt410784855(Point(29685, 26850), 4);
    connRef410784855->setSourceEndpoint(srcPt410784855);
    ConnEnd dstPt410784855(Point(29590, 26750), 8);
    connRef410784855->setDestEndpoint(dstPt410784855);
    connRef410784855->setRoutingType((ConnType)2);

    ConnRef *connRef15771480 = new ConnRef(router, 15771480);
    ConnEnd srcPt15771480(Point(29710, 26950), 4);
    connRef15771480->setSourceEndpoint(srcPt15771480);
    ConnEnd dstPt15771480(Point(29590, 26850), 8);
    connRef15771480->setDestEndpoint(dstPt15771480);
    connRef15771480->setRoutingType((ConnType)2);

    ConnRef *connRef34657402 = new ConnRef(router, 34657402);
    ConnEnd srcPt34657402(Point(29710, 27050), 4);
    connRef34657402->setSourceEndpoint(srcPt34657402);
    ConnEnd dstPt34657402(Point(29590, 26950), 8);
    connRef34657402->setDestEndpoint(dstPt34657402);
    connRef34657402->setRoutingType((ConnType)2);

    ConnRef *connRef98191218 = new ConnRef(router, 98191218);
    ConnEnd srcPt98191218(Point(29710, 27150), 4);
    connRef98191218->setSourceEndpoint(srcPt98191218);
    ConnEnd dstPt98191218(Point(29590, 27050), 8);
    connRef98191218->setDestEndpoint(dstPt98191218);
    connRef98191218->setRoutingType((ConnType)2);

    ConnRef *connRef23433311 = new ConnRef(router, 23433311);
    ConnEnd srcPt23433311(Point(29710, 27250), 4);
    connRef23433311->setSourceEndpoint(srcPt23433311);
    ConnEnd dstPt23433311(Point(29590, 27150), 8);
    connRef23433311->setDestEndpoint(dstPt23433311);
    connRef23433311->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("output/orneroverlap01");
    bool touching = router->existsOrthogonalTouchingPaths();
    delete router;
    return (touching) ? 1 : 0;
};

//.........这里部分代码省略.........
    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->outputInstanceToSVG("output/validPaths01");
    int result = router->existsInvalidOrthogonalPaths();
    delete router;
    return result;
};

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, 110);
    router->setOrthogonalNudgeDistance(25);

    Polygon poly426345871(4);
    poly426345871.ps[0] = Point(7200, 5240);
    poly426345871.ps[1] = Point(7200, 5660);
    poly426345871.ps[2] = Point(6690, 5660);
    poly426345871.ps[3] = Point(6690, 5240);
    ShapeRef *shapeRef426345871 = new ShapeRef(router, poly426345871, 426345871);
    router->addShape(shapeRef426345871);

    Polygon poly596896212(4);
    poly596896212.ps[0] = Point(7200, 5740);
    poly596896212.ps[1] = Point(7200, 6160);
    poly596896212.ps[2] = Point(6690, 6160);
    poly596896212.ps[3] = Point(6690, 5740);
    ShapeRef *shapeRef596896212 = new ShapeRef(router, poly596896212, 596896212);
    router->addShape(shapeRef596896212);

    ConnRef *connRef20026701 = new ConnRef(router, 20026701);
    ConnEnd srcPt20026701(Point(7190, 5600), 8);
    connRef20026701->setSourceEndpoint(srcPt20026701);
    ConnEnd dstPt20026701(Point(7190, 5800), 8);
    connRef20026701->setDestEndpoint(dstPt20026701);
    connRef20026701->setRoutingType((ConnType)2);

    ConnRef *connRef124776000 = new ConnRef(router, 124776000);
    ConnEnd srcPt124776000(Point(7190, 5550), 8);
    connRef124776000->setSourceEndpoint(srcPt124776000);
    ConnEnd dstPt124776000(Point(7190, 5850), 8);
    connRef124776000->setDestEndpoint(dstPt124776000);
    connRef124776000->setRoutingType((ConnType)2);

    ConnRef *connRef162425002 = new ConnRef(router, 162425002);
    ConnEnd srcPt162425002(Point(7190, 5500), 8);
    connRef162425002->setSourceEndpoint(srcPt162425002);
    ConnEnd dstPt162425002(Point(7190, 5900), 8);
    connRef162425002->setDestEndpoint(dstPt162425002);
    connRef162425002->setRoutingType((ConnType)2);

    ConnRef *connRef445102866 = new ConnRef(router, 445102866);
    ConnEnd srcPt445102866(Point(7190, 5450), 8);
    connRef445102866->setSourceEndpoint(srcPt445102866);
    ConnEnd dstPt445102866(Point(7190, 5950), 8);
    connRef445102866->setDestEndpoint(dstPt445102866);
    connRef445102866->setRoutingType((ConnType)2);

    ConnRef *connRef472520508 = new ConnRef(router, 472520508);
    ConnEnd srcPt472520508(Point(7190, 5400), 8);
    connRef472520508->setSourceEndpoint(srcPt472520508);
    ConnEnd dstPt472520508(Point(7190, 6000), 8);
    connRef472520508->setDestEndpoint(dstPt472520508);
    connRef472520508->setRoutingType((ConnType)2);

    ConnRef *connRef406587600 = new ConnRef(router, 406587600);
    ConnEnd srcPt406587600(Point(7190, 5350), 8);
    connRef406587600->setSourceEndpoint(srcPt406587600);
    ConnEnd dstPt406587600(Point(7190, 6050), 8);
    connRef406587600->setDestEndpoint(dstPt406587600);
    connRef406587600->setRoutingType((ConnType)2);

    ConnRef *connRef41657796 = new ConnRef(router, 41657796);
    ConnEnd srcPt41657796(Point(7190, 5300), 8);
    connRef41657796->setSourceEndpoint(srcPt41657796);
    ConnEnd dstPt41657796(Point(7190, 6100), 8);
    connRef41657796->setDestEndpoint(dstPt41657796);
    connRef41657796->setRoutingType((ConnType)2);

    router->processTransaction();
    router->outputInstanceToSVG("test-nudgeold");
    delete router;
    return 0;
};