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

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(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(
            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, 200);
    router->setRoutingPenalty((PenaltyType)3, 4000);
    router->setRoutingPenalty((PenaltyType)4, 9000);
    router->setRoutingPenalty((PenaltyType)5, 100);
    router->setRoutingOption((RoutingOption)0, false);
    router->setRoutingOption((RoutingOption)1, true);
    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);
//.........这里部分代码省略.........

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;
//.........这里部分代码省略.........

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);
    */
//.........这里部分代码省略.........

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;
};

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);

    Polygon poly219926511(4);
    poly219926511.ps[0] = Point(50760, 51240);
    poly219926511.ps[1] = Point(50760, 51260);
    poly219926511.ps[2] = Point(50740, 51260);
    poly219926511.ps[3] = Point(50740, 51240);
    ShapeRef *shapeRef219926511 = new ShapeRef(router, poly219926511, 219926511);
    router->addShape(shapeRef219926511);
    new ShapeConnectionPin(shapeRef219926511, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef219926511, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 1);
    new ShapeConnectionPin(shapeRef219926511, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 8);
    new ShapeConnectionPin(shapeRef219926511, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 2);

    Polygon poly171026375(4);
    poly171026375.ps[0] = Point(51085, 51215);
    poly171026375.ps[1] = Point(51085, 51235);
    poly171026375.ps[2] = Point(51065, 51235);
    poly171026375.ps[3] = Point(51065, 51215);
    ShapeRef *shapeRef171026375 = new ShapeRef(router, poly171026375, 171026375);
    router->addShape(shapeRef171026375);
    new ShapeConnectionPin(shapeRef171026375, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef171026375, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 1);
    new ShapeConnectionPin(shapeRef171026375, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 8);
    new ShapeConnectionPin(shapeRef171026375, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 2);

    Polygon poly878674(4);
    poly878674.ps[0] = Point(51454, 51200);
    poly878674.ps[1] = Point(51454, 51285);
    poly878674.ps[2] = Point(51396, 51285);
    poly878674.ps[3] = Point(51396, 51200);
    ShapeRef *shapeRef878674 = new ShapeRef(router, poly878674, 878674);
    router->addShape(shapeRef878674);

    Polygon poly286906544(4);
    poly286906544.ps[0] = Point(50704, 51250);
    poly286906544.ps[1] = Point(50704, 51335);
    poly286906544.ps[2] = Point(50646, 51335);
    poly286906544.ps[3] = Point(50646, 51250);
    ShapeRef *shapeRef286906544 = new ShapeRef(router, poly286906544, 286906544);
    router->addShape(shapeRef286906544);

    Polygon poly170813081(4);
    poly170813081.ps[0] = Point(51104, 51090);
    poly170813081.ps[1] = Point(51104, 51175);
    poly170813081.ps[2] = Point(51046, 51175);
    poly170813081.ps[3] = Point(51046, 51090);
    ShapeRef *shapeRef170813081 = new ShapeRef(router, poly170813081, 170813081);
    router->addShape(shapeRef170813081);

    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);
    router->addShape(shapeRef342721632);

    Polygon poly223927132(4);
    poly223927132.ps[0] = Point(51510, 51190);
    poly223927132.ps[1] = Point(51510, 51210);
    poly223927132.ps[2] = Point(51490, 51210);
    poly223927132.ps[3] = Point(51490, 51190);
    ShapeRef *shapeRef223927132 = new ShapeRef(router, poly223927132, 223927132);
    router->addShape(shapeRef223927132);
    new ShapeConnectionPin(shapeRef223927132, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef223927132, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 1);
    new ShapeConnectionPin(shapeRef223927132, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 8);
    new ShapeConnectionPin(shapeRef223927132, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 2);

    Polygon poly102578723(4);
    poly102578723.ps[0] = Point(51285, 50715);
    poly102578723.ps[1] = Point(51285, 50735);
    poly102578723.ps[2] = Point(51265, 50735);
    poly102578723.ps[3] = Point(51265, 50715);
    ShapeRef *shapeRef102578723 = new ShapeRef(router, poly102578723, 102578723);
    router->addShape(shapeRef102578723);
    new ShapeConnectionPin(shapeRef102578723, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef102578723, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 1);
    new ShapeConnectionPin(shapeRef102578723, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 8);
    new ShapeConnectionPin(shapeRef102578723, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 2);

    Polygon poly17922268(4);
    poly17922268.ps[0] = Point(50860, 50965);
    poly17922268.ps[1] = Point(50860, 50985);
    poly17922268.ps[2] = Point(50840, 50985);
    poly17922268.ps[3] = Point(50840, 50965);
    ShapeRef *shapeRef17922268 = new ShapeRef(router, poly17922268, 17922268);
    router->addShape(shapeRef17922268);
    new ShapeConnectionPin(shapeRef17922268, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 4);
    new ShapeConnectionPin(shapeRef17922268, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 1);
    new ShapeConnectionPin(shapeRef17922268, 2147483646, 0.5, 0.5, 0, (ConnDirFlags) 8);
//.........这里部分代码省略.........

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;
};

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(12);

    Polygon poly21424960(4);
    poly21424960.ps[0] = Point(29950, 27210);
    poly21424960.ps[1] = Point(29950, 27290);
    poly21424960.ps[2] = Point(29700, 27290);
    poly21424960.ps[3] = Point(29700, 27210);
    new ShapeRef(router, poly21424960, 21424960);
    
    Polygon poly435105790(4);
    poly435105790.ps[0] = Point(29950, 27110);
    poly435105790.ps[1] = Point(29950, 27190);
    poly435105790.ps[2] = Point(29700, 27190);
    poly435105790.ps[3] = Point(29700, 27110);
    new ShapeRef(router, poly435105790, 435105790);
    
    Polygon poly40787191(4);
    poly40787191.ps[0] = Point(29950, 27010);
    poly40787191.ps[1] = Point(29950, 27090);
    poly40787191.ps[2] = Point(29700, 27090);
    poly40787191.ps[3] = Point(29700, 27010);
    new ShapeRef(router, poly40787191, 40787191);
    
    Polygon poly76911264(4);
    poly76911264.ps[0] = Point(29950, 26910);
    poly76911264.ps[1] = Point(29950, 26990);
    poly76911264.ps[2] = Point(29700, 26990);
    poly76911264.ps[3] = Point(29700, 26910);
    new ShapeRef(router, poly76911264, 76911264);
    
    Polygon poly506213376(4);
    poly506213376.ps[0] = Point(29925, 26820);
    poly506213376.ps[1] = Point(29925, 26880);
    poly506213376.ps[2] = Point(29675, 26880);
    poly506213376.ps[3] = Point(29675, 26820);
    new ShapeRef(router, poly506213376, 506213376);
    
    Polygon poly134604636(4);
    poly134604636.ps[0] = Point(29925, 26720);
    poly134604636.ps[1] = Point(29925, 26780);
    poly134604636.ps[2] = Point(29675, 26780);
    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);
//.........这里部分代码省略.........

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;
};