boostvoronoi 0.12.1

use boostvoronoi::prelude::*;

mod common;
use common::{almost_equal, retrieve_point, to_points, to_segments};

type I = i32;

#[test]
/// The rust logo
fn large_segment_1() -> Result<(), BvError> {
    let (output, _v, _s) = {
        let points = to_points::<I>(&[
            [303, 108],
            [180, 257],
            [115, 405],
            [226, 536],
            [177, 599],
            [43, 709],
            [127, 740],
            [158, 683],
            [593, 759],
            [583, 672],
            [587, 543],
            [514, 503],
            [408, 543],
            [401, 642],
            [580, 380],
            [308, 304],
            [260, 343],
            [258, 240],
            [344, 238],
            [346, 189],
            [198, 150],
            [238, 59],
            [679, 37],
            [727, 134],
            [733, 276],
            [679, 327],
            [698, 404],
            [744, 544],
            [764, 673],
            [710, 770],
            [611, 687],
            [298, 536],
            [244, 675],
            [313, 618],
            [433, 760],
            [301, 773],
            [127, 758],
            [40, 644],
            [612, 105],
            [743, 37],
            [581, 26],
            [402, 20],
            [318, 45],
            [130, 102],
            [98, 141],
        ]);
        let segments = to_segments::<I>(&[
            [200, 200, 200, 400],
            [200, 400, 400, 400],
            [400, 400, 400, 200],
            [400, 200, 200, 200],
            [529, 242, 367, 107],
            [667, 431, 464, 554],
            [464, 554, 230, 588],
            [230, 588, 88, 464],
            [88, 464, 80, 236],
            [80, 236, 178, 97],
            [178, 97, 463, 56],
            [463, 56, 670, 175],
            [670, 175, 732, 346],
            [732, 346, 735, 479],
            [735, 479, 512, 643],
            [512, 643, 257, 710],
            [257, 710, 100, 615],
            [100, 615, 36, 470],
            [36, 470, 53, 195],
            [53, 195, 82, 83],
            [82, 83, 211, 30],
            [379, 35, 614, 55],
            [759, 140, 784, 390],
            [734, 594, 678, 686],
            [485, 742, 203, 745],
            [103, 724, 12, 537],
            [22, 425, 38, 45],
            [43, 25, 308, 17],
            [512, 691, 629, 758],
            [629, 758, 643, 601],
            [499, 455, 618, 281],
            [618, 281, 612, 209],
            [612, 209, 486, 125],
            [462, 458, 361, 494],
            [215, 498, 148, 470],
            [453, 233, 494, 371],
            [494, 371, 560, 262],
            [560, 262, 563, 200],
            [563, 200, 451, 141],
            [451, 141, 421, 82],
            [421, 82, 243, 111],
            [243, 111, 145, 187],
            [145, 187, 144, 319],
            [144, 319, 177, 442],
            [177, 442, 266, 484],
            [266, 484, 336, 541],
            [336, 541, 433, 497],
            [433, 497, 525, 467],
            [525, 467, 594, 427],
            [594, 427, 617, 342],
            [617, 342, 675, 292],
        ]);

        (
            Builder::<I>::default()
                .with_vertices(points.iter())?
                .with_segments(segments.iter())?
                .build()?,
            points,
            segments,
        )
    };
    assert_eq!(output.cells().len(), 161);
    let cell = output.cells()[0];
    assert_eq!(cell.id(), 0);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 12, y: 537 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[1];
    assert_eq!(cell.id(), 1);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 12, y: 537 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[2];
    assert_eq!(cell.id(), 2);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 22, y: 425 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[3];
    assert_eq!(cell.id(), 3);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 38, y: 45 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[4];
    assert_eq!(cell.id(), 4);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 36, y: 470 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[5];
    assert_eq!(cell.id(), 5);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 36, y: 470 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[6];
    assert_eq!(cell.id(), 6);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 53, y: 195 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[7];
    assert_eq!(cell.id(), 7);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 38, y: 45 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[8];
    assert_eq!(cell.id(), 8);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 40, y: 644 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[9];
    assert_eq!(cell.id(), 9);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 43, y: 25 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[10];
    assert_eq!(cell.id(), 10);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 43, y: 709 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[11];
    assert_eq!(cell.id(), 11);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 308, y: 17 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[12];
    assert_eq!(cell.id(), 12);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 53, y: 195 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[13];
    assert_eq!(cell.id(), 13);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 82, y: 83 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[14];
    assert_eq!(cell.id(), 14);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 80, y: 236 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[15];
    assert_eq!(cell.id(), 15);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 80, y: 236 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[16];
    assert_eq!(cell.id(), 16);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 178, y: 97 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[17];
    assert_eq!(cell.id(), 17);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 82, y: 83 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[18];
    assert_eq!(cell.id(), 18);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 211, y: 30 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[19];
    assert_eq!(cell.id(), 19);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 88, y: 464 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[20];
    assert_eq!(cell.id(), 20);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 88, y: 464 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[21];
    assert_eq!(cell.id(), 21);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 98, y: 141 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[22];
    assert_eq!(cell.id(), 22);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 100, y: 615 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[23];
    assert_eq!(cell.id(), 23);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 100, y: 615 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[24];
    assert_eq!(cell.id(), 24);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 103, y: 724 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[25];
    assert_eq!(cell.id(), 25);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 115, y: 405 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[26];
    assert_eq!(cell.id(), 26);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 127, y: 740 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[27];
    assert_eq!(cell.id(), 27);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 127, y: 758 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[28];
    assert_eq!(cell.id(), 28);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 130, y: 102 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[29];
    assert_eq!(cell.id(), 29);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 144, y: 319 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[30];
    assert_eq!(cell.id(), 30);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 177, y: 442 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[31];
    assert_eq!(cell.id(), 31);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 144, y: 319 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[32];
    assert_eq!(cell.id(), 32);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 145, y: 187 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[33];
    assert_eq!(cell.id(), 33);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 145, y: 187 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[34];
    assert_eq!(cell.id(), 34);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 148, y: 470 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[35];
    assert_eq!(cell.id(), 35);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 148, y: 470 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[36];
    assert_eq!(cell.id(), 36);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 158, y: 683 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[37];
    assert_eq!(cell.id(), 37);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 177, y: 442 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[38];
    assert_eq!(cell.id(), 38);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 177, y: 599 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[39];
    assert_eq!(cell.id(), 39);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 266, y: 484 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[40];
    assert_eq!(cell.id(), 40);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 178, y: 97 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[41];
    assert_eq!(cell.id(), 41);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 463, y: 56 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[42];
    assert_eq!(cell.id(), 42);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 180, y: 257 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[43];
    assert_eq!(cell.id(), 43);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 198, y: 150 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[44];
    assert_eq!(cell.id(), 44);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 200, y: 200 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[45];
    assert_eq!(cell.id(), 45);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 200, y: 400 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[46];
    assert_eq!(cell.id(), 46);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 200, y: 400 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[47];
    assert_eq!(cell.id(), 47);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 200, y: 200 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[48];
    assert_eq!(cell.id(), 48);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 400, y: 400 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[49];
    assert_eq!(cell.id(), 49);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 203, y: 745 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[50];
    assert_eq!(cell.id(), 50);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 203, y: 745 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[51];
    assert_eq!(cell.id(), 51);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 211, y: 30 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[52];
    assert_eq!(cell.id(), 52);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 215, y: 498 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[53];
    assert_eq!(cell.id(), 53);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 226, y: 536 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[54];
    assert_eq!(cell.id(), 54);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 230, y: 588 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[55];
    assert_eq!(cell.id(), 55);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 230, y: 588 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[56];
    assert_eq!(cell.id(), 56);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 238, y: 59 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[57];
    assert_eq!(cell.id(), 57);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 243, y: 111 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[58];
    assert_eq!(cell.id(), 58);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 243, y: 111 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[59];
    assert_eq!(cell.id(), 59);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 244, y: 675 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[60];
    assert_eq!(cell.id(), 60);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 257, y: 710 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[61];
    assert_eq!(cell.id(), 61);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 257, y: 710 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[62];
    assert_eq!(cell.id(), 62);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 258, y: 240 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[63];
    assert_eq!(cell.id(), 63);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 260, y: 343 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[64];
    assert_eq!(cell.id(), 64);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 266, y: 484 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[65];
    assert_eq!(cell.id(), 65);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 336, y: 541 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[66];
    assert_eq!(cell.id(), 66);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 298, y: 536 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[67];
    assert_eq!(cell.id(), 67);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 301, y: 773 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[68];
    assert_eq!(cell.id(), 68);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 303, y: 108 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[69];
    assert_eq!(cell.id(), 69);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 308, y: 17 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[70];
    assert_eq!(cell.id(), 70);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 308, y: 304 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[71];
    assert_eq!(cell.id(), 71);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 313, y: 618 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[72];
    assert_eq!(cell.id(), 72);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 318, y: 45 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[73];
    assert_eq!(cell.id(), 73);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 336, y: 541 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[74];
    assert_eq!(cell.id(), 74);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 433, y: 497 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[75];
    assert_eq!(cell.id(), 75);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 344, y: 238 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[76];
    assert_eq!(cell.id(), 76);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 346, y: 189 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[77];
    assert_eq!(cell.id(), 77);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 361, y: 494 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[78];
    assert_eq!(cell.id(), 78);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 361, y: 494 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[79];
    assert_eq!(cell.id(), 79);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 367, y: 107 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[80];
    assert_eq!(cell.id(), 80);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 367, y: 107 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[81];
    assert_eq!(cell.id(), 81);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 379, y: 35 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[82];
    assert_eq!(cell.id(), 82);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 614, y: 55 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[83];
    assert_eq!(cell.id(), 83);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 400, y: 200 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[84];
    assert_eq!(cell.id(), 84);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 400, y: 200 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[85];
    assert_eq!(cell.id(), 85);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 400, y: 400 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[86];
    assert_eq!(cell.id(), 86);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 401, y: 642 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[87];
    assert_eq!(cell.id(), 87);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 402, y: 20 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[88];
    assert_eq!(cell.id(), 88);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 408, y: 543 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[89];
    assert_eq!(cell.id(), 89);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 421, y: 82 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[90];
    assert_eq!(cell.id(), 90);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 421, y: 82 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[91];
    assert_eq!(cell.id(), 91);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 433, y: 497 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[92];
    assert_eq!(cell.id(), 92);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 433, y: 760 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[93];
    assert_eq!(cell.id(), 93);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 525, y: 467 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[94];
    assert_eq!(cell.id(), 94);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 451, y: 141 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[95];
    assert_eq!(cell.id(), 95);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 451, y: 141 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[96];
    assert_eq!(cell.id(), 96);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 453, y: 233 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[97];
    assert_eq!(cell.id(), 97);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 494, y: 371 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[98];
    assert_eq!(cell.id(), 98);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 462, y: 458 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[99];
    assert_eq!(cell.id(), 99);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 463, y: 56 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[100];
    assert_eq!(cell.id(), 100);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 670, y: 175 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[101];
    assert_eq!(cell.id(), 101);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 464, y: 554 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[102];
    assert_eq!(cell.id(), 102);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 464, y: 554 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[103];
    assert_eq!(cell.id(), 103);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 485, y: 742 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[104];
    assert_eq!(cell.id(), 104);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 486, y: 125 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[105];
    assert_eq!(cell.id(), 105);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 486, y: 125 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[106];
    assert_eq!(cell.id(), 106);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 494, y: 371 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[107];
    assert_eq!(cell.id(), 107);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 560, y: 262 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[108];
    assert_eq!(cell.id(), 108);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 499, y: 455 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[109];
    assert_eq!(cell.id(), 109);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 618, y: 281 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[110];
    assert_eq!(cell.id(), 110);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 512, y: 643 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[111];
    assert_eq!(cell.id(), 111);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 512, y: 691 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[112];
    assert_eq!(cell.id(), 112);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 512, y: 643 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[113];
    assert_eq!(cell.id(), 113);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 629, y: 758 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[114];
    assert_eq!(cell.id(), 114);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 514, y: 503 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[115];
    assert_eq!(cell.id(), 115);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 525, y: 467 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[116];
    assert_eq!(cell.id(), 116);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 594, y: 427 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[117];
    assert_eq!(cell.id(), 117);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 529, y: 242 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[118];
    assert_eq!(cell.id(), 118);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 560, y: 262 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[119];
    assert_eq!(cell.id(), 119);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 563, y: 200 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[120];
    assert_eq!(cell.id(), 120);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 563, y: 200 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[121];
    assert_eq!(cell.id(), 121);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 580, y: 380 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[122];
    assert_eq!(cell.id(), 122);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 581, y: 26 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[123];
    assert_eq!(cell.id(), 123);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 583, y: 672 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[124];
    assert_eq!(cell.id(), 124);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 587, y: 543 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[125];
    assert_eq!(cell.id(), 125);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 593, y: 759 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[126];
    assert_eq!(cell.id(), 126);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 594, y: 427 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[127];
    assert_eq!(cell.id(), 127);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 617, y: 342 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[128];
    assert_eq!(cell.id(), 128);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 611, y: 687 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[129];
    assert_eq!(cell.id(), 129);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 612, y: 105 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[130];
    assert_eq!(cell.id(), 130);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 612, y: 209 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[131];
    assert_eq!(cell.id(), 131);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 612, y: 209 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[132];
    assert_eq!(cell.id(), 132);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 614, y: 55 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[133];
    assert_eq!(cell.id(), 133);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 617, y: 342 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[134];
    assert_eq!(cell.id(), 134);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 675, y: 292 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[135];
    assert_eq!(cell.id(), 135);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 618, y: 281 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[136];
    assert_eq!(cell.id(), 136);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 629, y: 758 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[137];
    assert_eq!(cell.id(), 137);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 643, y: 601 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[138];
    assert_eq!(cell.id(), 138);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 643, y: 601 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[139];
    assert_eq!(cell.id(), 139);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 667, y: 431 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[140];
    assert_eq!(cell.id(), 140);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 670, y: 175 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[141];
    assert_eq!(cell.id(), 141);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 732, y: 346 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[142];
    assert_eq!(cell.id(), 142);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 675, y: 292 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[143];
    assert_eq!(cell.id(), 143);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 678, y: 686 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[144];
    assert_eq!(cell.id(), 144);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 678, y: 686 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[145];
    assert_eq!(cell.id(), 145);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 679, y: 37 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[146];
    assert_eq!(cell.id(), 146);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 679, y: 327 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[147];
    assert_eq!(cell.id(), 147);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 698, y: 404 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[148];
    assert_eq!(cell.id(), 148);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 710, y: 770 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[149];
    assert_eq!(cell.id(), 149);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 727, y: 134 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[150];
    assert_eq!(cell.id(), 150);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 732, y: 346 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[151];
    assert_eq!(cell.id(), 151);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 735, y: 479 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[152];
    assert_eq!(cell.id(), 152);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 733, y: 276 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[153];
    assert_eq!(cell.id(), 153);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 734, y: 594 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[154];
    assert_eq!(cell.id(), 154);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 735, y: 479 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[155];
    assert_eq!(cell.id(), 155);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 743, y: 37 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[156];
    assert_eq!(cell.id(), 156);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 744, y: 544 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[157];
    assert_eq!(cell.id(), 157);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 759, y: 140 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[158];
    assert_eq!(cell.id(), 158);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::Segment);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 784, y: 390 });
    assert!(!cell.is_degenerate());
    assert!(!cell.contains_point());
    assert!(cell.contains_segment());
    let cell = output.cells()[159];
    assert_eq!(cell.id(), 159);
    let (source_index, cat) = cell.source_index_2();
    assert_eq!(cat, SourceCategory::SinglePoint);
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 764, y: 673 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    let cell = output.cells()[160];
    assert_eq!(cell.id(), 160);
    let (source_index, cat) = cell.source_index_2();
    let p = retrieve_point(&_v, &_s, (source_index, cat));
    assert_eq!(p, Point { x: 784, y: 390 });
    assert!(!cell.is_degenerate());
    assert!(cell.contains_point());
    assert!(!cell.contains_segment());
    assert_eq!(output.vertices().len(), 304);
    assert_eq!(output.edges().len(), 928);
    let v = output.vertices()[0];
    assert!(almost_equal(v.x(), -1174.3944223, v.y(), 374.6254980));
    assert_eq!(v.get_incident_edge()?, 7);
    let v = output.vertices()[1];
    assert!(almost_equal(v.x(), 36.0000000, v.y(), 470.0000000));
    assert_eq!(v.get_incident_edge()?, 15);
    let v = output.vertices()[2];
    assert!(almost_equal(v.x(), -57.3429138, v.y(), 474.3622398));
    assert_eq!(v.get_incident_edge()?, 17);
    let v = output.vertices()[3];
    assert!(almost_equal(v.x(), -30.1728061, v.y(), 465.9093174));
    assert_eq!(v.get_incident_edge()?, 19);
    let v = output.vertices()[4];
    assert!(almost_equal(v.x(), 30.3683167, v.y(), 425.3523502));
    assert_eq!(v.get_incident_edge()?, 23);
    let v = output.vertices()[5];
    assert!(almost_equal(v.x(), -11.2724640, v.y(), 490.8650875));
    assert_eq!(v.get_incident_edge()?, 27);
    let v = output.vertices()[6];
    assert!(almost_equal(v.x(), -242.1180849, v.y(), 660.6617418));
    assert_eq!(v.get_incident_edge()?, 29);
    let v = output.vertices()[7];
    assert!(almost_equal(v.x(), -376.3385590, v.y(), 695.7848566));
    assert_eq!(v.get_incident_edge()?, 37);
    let v = output.vertices()[8];
    assert!(almost_equal(v.x(), 53.0000000, v.y(), 195.0000000));
    assert_eq!(v.get_incident_edge()?, 43);
    let v = output.vertices()[9];
    assert!(almost_equal(v.x(), 42.3708015, v.y(), 194.3429223));
    assert_eq!(v.get_incident_edge()?, 45);
    let v = output.vertices()[10];
    assert!(almost_equal(v.x(), 42.5755898, v.y(), 192.3008224));
    assert_eq!(v.get_incident_edge()?, 47);
    let v = output.vertices()[11];
    assert!(almost_equal(v.x(), 43.3231939, v.y(), 35.7057985));
    assert_eq!(v.get_incident_edge()?, 49);
    let v = output.vertices()[12];
    assert!(almost_equal(v.x(), -22930.4262948, v.y(), -922.0916335));
    assert_eq!(v.get_incident_edge()?, 51);
    let v = output.vertices()[13];
    assert!(almost_equal(v.x(), 34.0424487, v.y(), 526.2734608));
    assert_eq!(v.get_incident_edge()?, 53);
    let v = output.vertices()[14];
    assert!(almost_equal(v.x(), 43.5817605, v.y(), 676.4039187));
    assert_eq!(v.get_incident_edge()?, 55);
    let v = output.vertices()[15];
    assert!(almost_equal(v.x(), 80.0000000, v.y(), 236.0000000));
    assert_eq!(v.get_incident_edge()?, 63);
    let v = output.vertices()[16];
    assert!(almost_equal(v.x(), 65.2353585, v.y(), 236.5180576));
    assert_eq!(v.get_incident_edge()?, 65);
    let v = output.vertices()[17];
    assert!(almost_equal(v.x(), 59.3649404, v.y(), 45.8995764));
    assert_eq!(v.get_incident_edge()?, 67);
    let v = output.vertices()[18];
    assert!(almost_equal(v.x(), 82.0000000, v.y(), 83.0000000));
    assert_eq!(v.get_incident_edge()?, 73);
    let v = output.vertices()[19];
    assert!(almost_equal(v.x(), 59.6994840, v.y(), 77.2257592));
    assert_eq!(v.get_incident_edge()?, 75);
    let v = output.vertices()[20];
    assert!(almost_equal(v.x(), 66.9861495, v.y(), 226.8247673));
    assert_eq!(v.get_incident_edge()?, 77);
    let v = output.vertices()[21];
    assert!(almost_equal(v.x(), 88.0000000, v.y(), 464.0000000));
    assert_eq!(v.get_incident_edge()?, 83);
    let v = output.vertices()[22];
    assert!(almost_equal(v.x(), 62.1900542, v.y(), 464.9056121));
    assert_eq!(v.get_incident_edge()?, 85);
    let v = output.vertices()[23];
    assert!(almost_equal(v.x(), 62.1862043, v.y(), 465.3170750));
    assert_eq!(v.get_incident_edge()?, 87);
    let v = output.vertices()[24];
    assert!(almost_equal(v.x(), 70.7460129, v.y(), 483.7585982));
    assert_eq!(v.get_incident_edge()?, 89);
    let v = output.vertices()[25];
    assert!(almost_equal(v.x(), 68.5231008, v.y(), 55.1673809));
    assert_eq!(v.get_incident_edge()?, 93);
    let v = output.vertices()[26];
    assert!(almost_equal(v.x(), 100.0000000, v.y(), 615.0000000));
    assert_eq!(v.get_incident_edge()?, 99);
    let v = output.vertices()[27];
    assert!(almost_equal(v.x(), 76.8384688, v.y(), 198.7871843));
    assert_eq!(v.get_incident_edge()?, 101);
    let v = output.vertices()[28];
    assert!(almost_equal(v.x(), 70.3891562, v.y(), 54.7396443));
    assert_eq!(v.get_incident_edge()?, 103);
    let v = output.vertices()[29];
    assert!(almost_equal(v.x(), 79.4098241, v.y(), 624.0880777));
    assert_eq!(v.get_incident_edge()?, 105);
    let v = output.vertices()[30];
    assert!(almost_equal(v.x(), 66.7100457, v.y(), 741.6598174));
    assert_eq!(v.get_incident_edge()?, 109);
    let v = output.vertices()[31];
    assert!(almost_equal(v.x(), 87.3387120, v.y(), 635.9244443));
    assert_eq!(v.get_incident_edge()?, 111);
    let v = output.vertices()[32];
    assert!(almost_equal(v.x(), 90.2866683, v.y(), 169.7504629));
    assert_eq!(v.get_incident_edge()?, 115);
    let v = output.vertices()[33];
    assert!(almost_equal(v.x(), 103.6666667, v.y(), 749.0000000));
    assert_eq!(v.get_incident_edge()?, 121);
    let v = output.vertices()[34];
    assert!(almost_equal(v.x(), 103.9513759, v.y(), 102.1430840));
    assert_eq!(v.get_incident_edge()?, 125);
    let v = output.vertices()[35];
    assert!(almost_equal(v.x(), 56.5625000, v.y(), 782.2500000));
    assert_eq!(v.get_incident_edge()?, 127);
    let v = output.vertices()[36];
    assert!(almost_equal(v.x(), 103.6928324, v.y(), 113.0428369));
    assert_eq!(v.get_incident_edge()?, 129);
    let v = output.vertices()[37];
    assert!(almost_equal(v.x(), 144.0000000, v.y(), 319.0000000));
    assert_eq!(v.get_incident_edge()?, 137);
    let v = output.vertices()[38];
    assert!(almost_equal(v.x(), 113.4619164, v.y(), 318.7686509));
    assert_eq!(v.get_incident_edge()?, 139);
    let v = output.vertices()[39];
    assert!(almost_equal(v.x(), 112.4568064, v.y(), 245.6682878));
    assert_eq!(v.get_incident_edge()?, 141);
    let v = output.vertices()[40];
    assert!(almost_equal(v.x(), 145.0000000, v.y(), 187.0000000));
    assert_eq!(v.get_incident_edge()?, 147);
    let v = output.vertices()[41];
    assert!(almost_equal(v.x(), 131.3372641, v.y(), 186.8964944));
    assert_eq!(v.get_incident_edge()?, 149);
    let v = output.vertices()[42];
    assert!(almost_equal(v.x(), 114.1343309, v.y(), 327.0127405));
    assert_eq!(v.get_incident_edge()?, 151);
    let v = output.vertices()[43];
    assert!(almost_equal(v.x(), 122.3376920, v.y(), 128.3411832));
    assert_eq!(v.get_incident_edge()?, 157);
    let v = output.vertices()[44];
    assert!(almost_equal(v.x(), 137.2028817, v.y(), 176.9458211));
    assert_eq!(v.get_incident_edge()?, 159);
    let v = output.vertices()[45];
    assert!(almost_equal(v.x(), 121.7452809, v.y(), 447.9473901));
    assert_eq!(v.get_incident_edge()?, 161);
    let v = output.vertices()[46];
    assert!(almost_equal(v.x(), 120.5132924, v.y(), 369.6243596));
    assert_eq!(v.get_incident_edge()?, 163);
    let v = output.vertices()[47];
    assert!(almost_equal(v.x(), 128.6569921, v.y(), 711.5145119));
    assert_eq!(v.get_incident_edge()?, 165);
    let v = output.vertices()[48];
    assert!(almost_equal(v.x(), 141.0848907, v.y(), 486.5468686));
    assert_eq!(v.get_incident_edge()?, 169);
    let v = output.vertices()[49];
    assert!(almost_equal(v.x(), 120.8761604, v.y(), 672.6712790));
    assert_eq!(v.get_incident_edge()?, 171);
    let v = output.vertices()[50];
    assert!(almost_equal(v.x(), 124.5018028, v.y(), 441.0529309));
    assert_eq!(v.get_incident_edge()?, 173);
    let v = output.vertices()[51];
    assert!(almost_equal(v.x(), 132.5058123, v.y(), 706.0645646));
    assert_eq!(v.get_incident_edge()?, 175);
    let v = output.vertices()[52];
    assert!(almost_equal(v.x(), 136.8261871, v.y(), 434.7959358));
    assert_eq!(v.get_incident_edge()?, 177);
    let v = output.vertices()[53];
    assert!(almost_equal(v.x(), 177.0000000, v.y(), 442.0000000));
    assert_eq!(v.get_incident_edge()?, 185);
    let v = output.vertices()[54];
    assert!(almost_equal(v.x(), 154.7471610, v.y(), 447.9702739));
    assert_eq!(v.get_incident_edge()?, 187);
    let v = output.vertices()[55];
    assert!(almost_equal(v.x(), 178.0000000, v.y(), 97.0000000));
    assert_eq!(v.get_incident_edge()?, 193);
    let v = output.vertices()[56];
    assert!(almost_equal(v.x(), 156.4635417, v.y(), 449.7479539));
    assert_eq!(v.get_incident_edge()?, 195);
    let v = output.vertices()[57];
    assert!(almost_equal(v.x(), 135.0400623, v.y(), 584.1961079));
    assert_eq!(v.get_incident_edge()?, 197);
    let v = output.vertices()[58];
    assert!(almost_equal(v.x(), 152.2164348, v.y(), 84.6357643));
    assert_eq!(v.get_incident_edge()?, 201);
    let v = output.vertices()[59];
    assert!(almost_equal(v.x(), 156.0857605, v.y(), 81.5496728));
    assert_eq!(v.get_incident_edge()?, 203);
    let v = output.vertices()[60];
    assert!(almost_equal(v.x(), 135.3473554, v.y(), 571.5629890));
    assert_eq!(v.get_incident_edge()?, 205);
    let v = output.vertices()[61];
    assert!(almost_equal(v.x(), 169.0970276, v.y(), 458.7467748));
    assert_eq!(v.get_incident_edge()?, 207);
    let v = output.vertices()[62];
    assert!(almost_equal(v.x(), 174.4263632, v.y(), 72.1588663));
    assert_eq!(v.get_incident_edge()?, 211);
    let v = output.vertices()[63];
    assert!(almost_equal(v.x(), 172.7321989, v.y(), 200.0000000));
    assert_eq!(v.get_incident_edge()?, 217);
    let v = output.vertices()[64];
    assert!(almost_equal(v.x(), 172.4489632, v.y(), 200.5780786));
    assert_eq!(v.get_incident_edge()?, 219);
    let v = output.vertices()[65];
    assert!(almost_equal(v.x(), 172.3359319, v.y(), 230.4187524));
    assert_eq!(v.get_incident_edge()?, 221);
    let v = output.vertices()[66];
    assert!(almost_equal(v.x(), 172.1339878, v.y(), 283.7327605));
    assert_eq!(v.get_incident_edge()?, 223);
    let v = output.vertices()[67];
    assert!(almost_equal(v.x(), 172.0139802, v.y(), 315.4152249));
    assert_eq!(v.get_incident_edge()?, 225);
    let v = output.vertices()[68];
    assert!(almost_equal(v.x(), 183.1635651, v.y(), 400.0000000));
    assert_eq!(v.get_incident_edge()?, 229);
    let v = output.vertices()[69];
    assert!(almost_equal(v.x(), 200.0000000, v.y(), 200.0000000));
    assert_eq!(v.get_incident_edge()?, 233);
    let v = output.vertices()[70];
    assert!(almost_equal(v.x(), 200.0000000, v.y(), 400.0000000));
    assert_eq!(v.get_incident_edge()?, 237);
    let v = output.vertices()[71];
    assert!(almost_equal(v.x(), 164.5723684, v.y(), 749.0000000));
    assert_eq!(v.get_incident_edge()?, 243);
    let v = output.vertices()[72];
    assert!(almost_equal(v.x(), 166.1917762, v.y(), 724.3850011));
    assert_eq!(v.get_incident_edge()?, 245);
    let v = output.vertices()[73];
    assert!(almost_equal(v.x(), 209.0238909, v.y(), 25.1902251));
    assert_eq!(v.get_incident_edge()?, 249);
    let v = output.vertices()[74];
    assert!(almost_equal(v.x(), 191.9065740, v.y(), 119.6929455));
    assert_eq!(v.get_incident_edge()?, 253);
    let v = output.vertices()[75];
    assert!(almost_equal(v.x(), 197.8607829, v.y(), 424.5715117));
    assert_eq!(v.get_incident_edge()?, 255);
    let v = output.vertices()[76];
    assert!(almost_equal(v.x(), 184.3835006, v.y(), 711.1813302));
    assert_eq!(v.get_incident_edge()?, 257);
    let v = output.vertices()[77];
    assert!(almost_equal(v.x(), 200.0000000, v.y(), 175.4342171));
    assert_eq!(v.get_incident_edge()?, 259);
    let v = output.vertices()[78];
    assert!(almost_equal(v.x(), 200.0000000, v.y(), 425.0997269));
    assert_eq!(v.get_incident_edge()?, 261);
    let v = output.vertices()[79];
    assert!(almost_equal(v.x(), 201.6597254, v.y(), 174.8660641));
    assert_eq!(v.get_incident_edge()?, 265);
    let v = output.vertices()[80];
    assert!(almost_equal(v.x(), 199.9344795, v.y(), 523.1841408));
    assert_eq!(v.get_incident_edge()?, 267);
    let v = output.vertices()[81];
    assert!(almost_equal(v.x(), 230.0000000, v.y(), 588.0000000));
    assert_eq!(v.get_incident_edge()?, 273);
    let v = output.vertices()[82];
    assert!(almost_equal(v.x(), 205.2100089, v.y(), 521.4260500));
    assert_eq!(v.get_incident_edge()?, 275);
    let v = output.vertices()[83];
    assert!(almost_equal(v.x(), 202.6670680, v.y(), 713.7043925));
    assert_eq!(v.get_incident_edge()?, 277);
    let v = output.vertices()[84];
    assert!(almost_equal(v.x(), 208.7641689, v.y(), 62.7902787));
    assert_eq!(v.get_incident_edge()?, 281);
    let v = output.vertices()[85];
    assert!(almost_equal(v.x(), 221.6406921, v.y(), 482.1097726));
    assert_eq!(v.get_incident_edge()?, 283);
    let v = output.vertices()[86];
    assert!(almost_equal(v.x(), 219.0442769, v.y(), 49.5794664));
    assert_eq!(v.get_incident_edge()?, 285);
    let v = output.vertices()[87];
    assert!(almost_equal(v.x(), 207.6665847, v.y(), 613.5753627));
    assert_eq!(v.get_incident_edge()?, 287);
    let v = output.vertices()[88];
    assert!(almost_equal(v.x(), 243.0000000, v.y(), 111.0000000));
    assert_eq!(v.get_incident_edge()?, 293);
    let v = output.vertices()[89];
    assert!(almost_equal(v.x(), 235.4232780, v.y(), 101.2300164));
    assert_eq!(v.get_incident_edge()?, 297);
    let v = output.vertices()[90];
    assert!(almost_equal(v.x(), 229.1313403, v.y(), 40.1880625));
    assert_eq!(v.get_incident_edge()?, 299);
    let v = output.vertices()[91];
    assert!(almost_equal(v.x(), 241.1415449, v.y(), 99.5929305));
    assert_eq!(v.get_incident_edge()?, 301);
    let v = output.vertices()[92];
    assert!(almost_equal(v.x(), 210.8909700, v.y(), 629.1110373));
    assert_eq!(v.get_incident_edge()?, 303);
    let v = output.vertices()[93];
    assert!(almost_equal(v.x(), 257.0000000, v.y(), 710.0000000));
    assert_eq!(v.get_incident_edge()?, 309);
    let v = output.vertices()[94];
    assert!(almost_equal(v.x(), 229.8824545, v.y(), 229.8824545));
    assert_eq!(v.get_incident_edge()?, 313);
    let v = output.vertices()[95];
    assert!(almost_equal(v.x(), 228.5720220, v.y(), 165.6535147));
    assert_eq!(v.get_incident_edge()?, 317);
    let v = output.vertices()[96];
    assert!(almost_equal(v.x(), 238.3312309, v.y(), 559.7489573));
    assert_eq!(v.get_incident_edge()?, 319);
    let v = output.vertices()[97];
    assert!(almost_equal(v.x(), 247.3670632, v.y(), 725.9196956));
    assert_eq!(v.get_incident_edge()?, 321);
    let v = output.vertices()[98];
    assert!(almost_equal(v.x(), 266.0000000, v.y(), 484.0000000));
    assert_eq!(v.get_incident_edge()?, 327);
    let v = output.vertices()[99];
    assert!(almost_equal(v.x(), 221.6243311, v.y(), 633.9742456));
    assert_eq!(v.get_incident_edge()?, 329);
    let v = output.vertices()[100];
    assert!(almost_equal(v.x(), 234.2957075, v.y(), 365.7042925));
    assert_eq!(v.get_incident_edge()?, 331);
    let v = output.vertices()[101];
    assert!(almost_equal(v.x(), 245.0763323, v.y(), 509.8857985));
    assert_eq!(v.get_incident_edge()?, 333);
    let v = output.vertices()[102];
    assert!(almost_equal(v.x(), 261.4408687, v.y(), 726.9018136));
    assert_eq!(v.get_incident_edge()?, 335);
    let v = output.vertices()[103];
    assert!(almost_equal(v.x(), 236.3360372, v.y(), 631.6068446));
    assert_eq!(v.get_incident_edge()?, 337);
    let v = output.vertices()[104];
    assert!(almost_equal(v.x(), 260.2101571, v.y(), 687.8005985));
    assert_eq!(v.get_incident_edge()?, 339);
    let v = output.vertices()[105];
    assert!(almost_equal(v.x(), 248.3738450, v.y(), 511.9798227));
    assert_eq!(v.get_incident_edge()?, 341);
    let v = output.vertices()[106];
    assert!(almost_equal(v.x(), 262.0000000, v.y(), 528.2358142));
    assert_eq!(v.get_incident_edge()?, 345);
    let v = output.vertices()[107];
    assert!(almost_equal(v.x(), 262.0000000, v.y(), 545.6802052));
    assert_eq!(v.get_incident_edge()?, 347);
    let v = output.vertices()[108];
    assert!(almost_equal(v.x(), 269.6162952, v.y(), 50.8287818));
    assert_eq!(v.get_incident_edge()?, 351);
    let v = output.vertices()[109];
    assert!(almost_equal(v.x(), 251.9853267, v.y(), 291.6362072));
    assert_eq!(v.get_incident_edge()?, 355);
    let v = output.vertices()[110];
    assert!(almost_equal(v.x(), 261.8343867, v.y(), 154.2672261));
    assert_eq!(v.get_incident_edge()?, 357);
    let v = output.vertices()[111];
    assert!(almost_equal(v.x(), 258.0155317, v.y(), 291.5191159));
    assert_eq!(v.get_incident_edge()?, 363);
    let v = output.vertices()[112];
    assert!(almost_equal(v.x(), 266.3920861, v.y(), 631.8430516));
    assert_eq!(v.get_incident_edge()?, 367);
    let v = output.vertices()[113];
    assert!(almost_equal(v.x(), 286.6059238, v.y(), 49.3549986));
    assert_eq!(v.get_incident_edge()?, 371);
    let v = output.vertices()[114];
    assert!(almost_equal(v.x(), 308.4714667, v.y(), 32.6173333));
    assert_eq!(v.get_incident_edge()?, 373);
    let v = output.vertices()[115];
    assert!(almost_equal(v.x(), 284.8247952, v.y(), 444.1093626));
    assert_eq!(v.get_incident_edge()?, 375);
    let v = output.vertices()[116];
    assert!(almost_equal(v.x(), 285.4433922, v.y(), 654.9051590));
    assert_eq!(v.get_incident_edge()?, 377);
    let v = output.vertices()[117];
    assert!(almost_equal(v.x(), 285.5606950, v.y(), 152.3471231));
    assert_eq!(v.get_incident_edge()?, 379);
    let v = output.vertices()[118];
    assert!(almost_equal(v.x(), 336.0000000, v.y(), 541.0000000));
    assert_eq!(v.get_incident_edge()?, 385);
    let v = output.vertices()[119];
    assert!(almost_equal(v.x(), 313.8723560, v.y(), 552.6029228));
    assert_eq!(v.get_incident_edge()?, 387);
    let v = output.vertices()[120];
    assert!(almost_equal(v.x(), 324.2232914, v.y(), 555.4626247));
    assert_eq!(v.get_incident_edge()?, 389);
    let v = output.vertices()[121];
    assert!(almost_equal(v.x(), 295.8742489, v.y(), 447.3123259));
    assert_eq!(v.get_incident_edge()?, 391);
    let v = output.vertices()[122];
    assert!(almost_equal(v.x(), 301.0980947, v.y(), 243.2180721));
    assert_eq!(v.get_incident_edge()?, 395);
    let v = output.vertices()[123];
    assert!(almost_equal(v.x(), 301.4325482, v.y(), 257.5995717));
    assert_eq!(v.get_incident_edge()?, 399);
    let v = output.vertices()[124];
    assert!(almost_equal(v.x(), 307.1532156, v.y(), 351.9962654));
    assert_eq!(v.get_incident_edge()?, 401);
    let v = output.vertices()[125];
    assert!(almost_equal(v.x(), 342.5884507, v.y(), 555.5245390));
    assert_eq!(v.get_incident_edge()?, 403);
    let v = output.vertices()[126];
    assert!(almost_equal(v.x(), 315.8228628, v.y(), 153.1063815));
    assert_eq!(v.get_incident_edge()?, 409);
    let v = output.vertices()[127];
    assert!(almost_equal(v.x(), 339.9989303, v.y(), 510.1171002));
    assert_eq!(v.get_incident_edge()?, 411);
    let v = output.vertices()[128];
    assert!(almost_equal(v.x(), 320.0618342, v.y(), 455.9145395));
    assert_eq!(v.get_incident_edge()?, 417);
    let v = output.vertices()[129];
    assert!(almost_equal(v.x(), 348.6958227, v.y(), 41.1945186));
    assert_eq!(v.get_incident_edge()?, 423);
    let v = output.vertices()[130];
    assert!(almost_equal(v.x(), 333.2976577, v.y(), 143.8296385));
    assert_eq!(v.get_incident_edge()?, 425);
    let v = output.vertices()[131];
    assert!(almost_equal(v.x(), 345.1426991, v.y(), 19.5204646));
    assert_eq!(v.get_incident_edge()?, 427);
    let v = output.vertices()[132];
    assert!(almost_equal(v.x(), 366.4611605, v.y(), 509.3215891));
    assert_eq!(v.get_incident_edge()?, 429);
    let v = output.vertices()[133];
    assert!(almost_equal(v.x(), 373.1847157, v.y(), 99.5783412));
    assert_eq!(v.get_incident_edge()?, 431);
    let v = output.vertices()[134];
    assert!(almost_equal(v.x(), 337.3019780, v.y(), 142.6376264));
    assert_eq!(v.get_incident_edge()?, 433);
    let v = output.vertices()[135];
    assert!(almost_equal(v.x(), 204.9025641, v.y(), 923.8410256));
    assert_eq!(v.get_incident_edge()?, 435);
    let v = output.vertices()[136];
    assert!(almost_equal(v.x(), 337.1881287, v.y(), 143.0544731));
    assert_eq!(v.get_incident_edge()?, 437);
    let v = output.vertices()[137];
    assert!(almost_equal(v.x(), 344.7482761, v.y(), 448.4048858));
    assert_eq!(v.get_incident_edge()?, 439);
    let v = output.vertices()[138];
    assert!(almost_equal(v.x(), 377.5933595, v.y(), 51.5280262));
    assert_eq!(v.get_incident_edge()?, 441);
    let v = output.vertices()[139];
    assert!(almost_equal(v.x(), 400.0000000, v.y(), 200.0000000));
    assert_eq!(v.get_incident_edge()?, 447);
    let v = output.vertices()[140];
    assert!(almost_equal(v.x(), 371.2380257, v.y(), 228.7619743));
    assert_eq!(v.get_incident_edge()?, 449);
    let v = output.vertices()[141];
    assert!(almost_equal(v.x(), 352.0848706, v.y(), 285.2281112));
    assert_eq!(v.get_incident_edge()?, 451);
    let v = output.vertices()[142];
    assert!(almost_equal(v.x(), 344.9059818, v.y(), 344.9059818));
    assert_eq!(v.get_incident_edge()?, 453);
    let v = output.vertices()[143];
    assert!(almost_equal(v.x(), 400.0000000, v.y(), 400.0000000));
    assert_eq!(v.get_incident_edge()?, 457);
    let v = output.vertices()[144];
    assert!(almost_equal(v.x(), 198.3827160, v.y(), 946.6604938));
    assert_eq!(v.get_incident_edge()?, 459);
    let v = output.vertices()[145];
    assert!(almost_equal(v.x(), 355.2211116, v.y(), 636.5225907));
    assert_eq!(v.get_incident_edge()?, 463);
    let v = output.vertices()[146];
    assert!(almost_equal(v.x(), 380.8920954, v.y(), 12.7678795));
    assert_eq!(v.get_incident_edge()?, 467);
    let v = output.vertices()[147];
    assert!(almost_equal(v.x(), 385.7416252, v.y(), 542.8784343));
    assert_eq!(v.get_incident_edge()?, 471);
    let v = output.vertices()[148];
    assert!(almost_equal(v.x(), 360.5265260, v.y(), 617.0694048));
    assert_eq!(v.get_incident_edge()?, 473);
    let v = output.vertices()[149];
    assert!(almost_equal(v.x(), 372.8562699, v.y(), 161.7154894));
    assert_eq!(v.get_incident_edge()?, 475);
    let v = output.vertices()[150];
    assert!(almost_equal(v.x(), 356.3823529, v.y(), -24.8137255));
    assert_eq!(v.get_incident_edge()?, 477);
    let v = output.vertices()[151];
    assert!(almost_equal(v.x(), 421.0000000, v.y(), 82.0000000));
    assert_eq!(v.get_incident_edge()?, 483);
    let v = output.vertices()[152];
    assert!(almost_equal(v.x(), 400.0000000, v.y(), 171.5428751));
    assert_eq!(v.get_incident_edge()?, 485);
    let v = output.vertices()[153];
    assert!(almost_equal(v.x(), 419.4115863, v.y(), 72.2504265));
    assert_eq!(v.get_incident_edge()?, 487);
    let v = output.vertices()[154];
    assert!(almost_equal(v.x(), 407.3496843, v.y(), 108.9094919));
    assert_eq!(v.get_incident_edge()?, 489);
    let v = output.vertices()[155];
    assert!(almost_equal(v.x(), 433.0000000, v.y(), 497.0000000));
    assert_eq!(v.get_incident_edge()?, 497);
    let v = output.vertices()[156];
    assert!(almost_equal(v.x(), 400.0000000, v.y(), 438.8523777));
    assert_eq!(v.get_incident_edge()?, 499);
    let v = output.vertices()[157];
    assert!(almost_equal(v.x(), 427.4135860, v.y(), 484.6844964));
    assert_eq!(v.get_incident_edge()?, 501);
    let v = output.vertices()[158];
    assert!(almost_equal(v.x(), 428.8140207, v.y(), 484.1629967));
    assert_eq!(v.get_incident_edge()?, 503);
    let v = output.vertices()[159];
    assert!(almost_equal(v.x(), 434.3229054, v.y(), 75.2256413));
    assert_eq!(v.get_incident_edge()?, 505);
    let v = output.vertices()[160];
    assert!(almost_equal(v.x(), 451.0000000, v.y(), 141.0000000));
    assert_eq!(v.get_incident_edge()?, 511);
    let v = output.vertices()[161];
    assert!(almost_equal(v.x(), 438.1526246, v.y(), 147.5325638));
    assert_eq!(v.get_incident_edge()?, 513);
    let v = output.vertices()[162];
    assert!(almost_equal(v.x(), 427.0603160, v.y(), 240.7067177));
    assert_eq!(v.get_incident_edge()?, 519);
    let v = output.vertices()[163];
    assert!(almost_equal(v.x(), 444.4836586, v.y(), 153.3700040));
    assert_eq!(v.get_incident_edge()?, 521);
    let v = output.vertices()[164];
    assert!(almost_equal(v.x(), 430.6785590, v.y(), 200.0000000));
    assert_eq!(v.get_incident_edge()?, 523);
    let v = output.vertices()[165];
    assert!(almost_equal(v.x(), 433.6088985, v.y(), 528.8508555));
    assert_eq!(v.get_incident_edge()?, 527);
    let v = output.vertices()[166];
    assert!(almost_equal(v.x(), 463.0000000, v.y(), 56.0000000));
    assert_eq!(v.get_incident_edge()?, 533);
    let v = output.vertices()[167];
    assert!(almost_equal(v.x(), 464.0000000, v.y(), 554.0000000));
    assert_eq!(v.get_incident_edge()?, 539);
    let v = output.vertices()[168];
    assert!(almost_equal(v.x(), 433.4354821, v.y(), 205.8861456));
    assert_eq!(v.get_incident_edge()?, 541);
    let v = output.vertices()[169];
    assert!(almost_equal(v.x(), 462.0045434, v.y(), 49.0803625));
    assert_eq!(v.get_incident_edge()?, 543);
    let v = output.vertices()[170];
    assert!(almost_equal(v.x(), 466.6086393, v.y(), 49.7227871));
    assert_eq!(v.get_incident_edge()?, 545);
    let v = output.vertices()[171];
    assert!(almost_equal(v.x(), 444.1708802, v.y(), 525.7556504));
    assert_eq!(v.get_incident_edge()?, 547);
    let v = output.vertices()[172];
    assert!(almost_equal(v.x(), 466.7160588, v.y(), 471.2311650));
    assert_eq!(v.get_incident_edge()?, 549);
    let v = output.vertices()[173];
    assert!(almost_equal(v.x(), 375.2807514, v.y(), 850.5814757));
    assert_eq!(v.get_incident_edge()?, 551);
    let v = output.vertices()[174];
    assert!(almost_equal(v.x(), 453.1144143, v.y(), 523.6639203));
    assert_eq!(v.get_incident_edge()?, 553);
    let v = output.vertices()[175];
    assert!(almost_equal(v.x(), 465.9853449, v.y(), 126.2295195));
    assert_eq!(v.get_incident_edge()?, 561);
    let v = output.vertices()[176];
    assert!(almost_equal(v.x(), 457.0519803, v.y(), 87.0227389));
    assert_eq!(v.get_incident_edge()?, 563);
    let v = output.vertices()[177];
    assert!(almost_equal(v.x(), 440.0618632, v.y(), 609.0911561));
    assert_eq!(v.get_incident_edge()?, 565);
    let v = output.vertices()[178];
    assert!(almost_equal(v.x(), 477.5270465, v.y(), 137.7094302));
    assert_eq!(v.get_incident_edge()?, 567);
    let v = output.vertices()[179];
    assert!(almost_equal(v.x(), 445.9624227, v.y(), 413.0056860));
    assert_eq!(v.get_incident_edge()?, 569);
    let v = output.vertices()[180];
    assert!(almost_equal(v.x(), 494.0000000, v.y(), 371.0000000));
    assert_eq!(v.get_incident_edge()?, 575);
    let v = output.vertices()[181];
    assert!(almost_equal(v.x(), 447.9937680, v.y(), 384.6685182));
    assert_eq!(v.get_incident_edge()?, 577);
    let v = output.vertices()[182];
    assert!(almost_equal(v.x(), 474.8348325, v.y(), 226.5128396));
    assert_eq!(v.get_incident_edge()?, 579);
    let v = output.vertices()[183];
    assert!(almost_equal(v.x(), 480.8838423, v.y(), 461.2340549));
    assert_eq!(v.get_incident_edge()?, 585);
    let v = output.vertices()[184];
    assert!(almost_equal(v.x(), 466.7018481, v.y(), 97.1811906));
    assert_eq!(v.get_incident_edge()?, 587);
    let v = output.vertices()[185];
    assert!(almost_equal(v.x(), 451.4734043, v.y(), 400.0000000));
    assert_eq!(v.get_incident_edge()?, 589);
    let v = output.vertices()[186];
    assert!(almost_equal(v.x(), 479.2851505, v.y(), 441.5168558));
    assert_eq!(v.get_incident_edge()?, 591);
    let v = output.vertices()[187];
    assert!(almost_equal(v.x(), 453.1240000, v.y(), 405.3502069));
    assert_eq!(v.get_incident_edge()?, 593);
    let v = output.vertices()[188];
    assert!(almost_equal(v.x(), 512.0000000, v.y(), 643.0000000));
    assert_eq!(v.get_incident_edge()?, 601);
    let v = output.vertices()[189];
    assert!(almost_equal(v.x(), 469.4682806, v.y(), 698.9030418));
    assert_eq!(v.get_incident_edge()?, 605);
    let v = output.vertices()[190];
    assert!(almost_equal(v.x(), 487.1751523, v.y(), 508.0435798));
    assert_eq!(v.get_incident_edge()?, 609);
    let v = output.vertices()[191];
    assert!(almost_equal(v.x(), 484.6507237, v.y(), 709.1680302));
    assert_eq!(v.get_incident_edge()?, 611);
    let v = output.vertices()[192];
    assert!(almost_equal(v.x(), 471.5545509, v.y(), 412.1292601));
    assert_eq!(v.get_incident_edge()?, 613);
    let v = output.vertices()[193];
    assert!(almost_equal(v.x(), 507.9648712, v.y(), 461.1311476));
    assert_eq!(v.get_incident_edge()?, 615);
    let v = output.vertices()[194];
    assert!(almost_equal(v.x(), 471.0879873, v.y(), 602.7820301));
    assert_eq!(v.get_incident_edge()?, 617);
    let v = output.vertices()[195];
    assert!(almost_equal(v.x(), 499.4264473, v.y(), 104.8603291));
    assert_eq!(v.get_incident_edge()?, 619);
    let v = output.vertices()[196];
    assert!(almost_equal(v.x(), 525.0000000, v.y(), 467.0000000));
    assert_eq!(v.get_incident_edge()?, 625);
    let v = output.vertices()[197];
    assert!(almost_equal(v.x(), 497.6539352, v.y(), 716.0520833));
    assert_eq!(v.get_incident_edge()?, 627);
    let v = output.vertices()[198];
    assert!(almost_equal(v.x(), 518.7613497, v.y(), 453.0408324));
    assert_eq!(v.get_incident_edge()?, 631);
    let v = output.vertices()[199];
    assert!(almost_equal(v.x(), 489.9905970, v.y(), 596.9113752));
    assert_eq!(v.get_incident_edge()?, 633);
    let v = output.vertices()[200];
    assert!(almost_equal(v.x(), 489.9976364, v.y(), 596.9066682));
    assert_eq!(v.get_incident_edge()?, 635);
    let v = output.vertices()[201];
    assert!(almost_equal(v.x(), 516.0634823, v.y(), 384.3595397));
    assert_eq!(v.get_incident_edge()?, 637);
    let v = output.vertices()[202];
    assert!(almost_equal(v.x(), 504.4438216, v.y(), 271.4674140));
    assert_eq!(v.get_incident_edge()?, 639);
    let v = output.vertices()[203];
    assert!(almost_equal(v.x(), 518.3058824, v.y(), 667.0000000));
    assert_eq!(v.get_incident_edge()?, 641);
    let v = output.vertices()[204];
    assert!(almost_equal(v.x(), 506.4241349, v.y(), 274.3379841));
    assert_eq!(v.get_incident_edge()?, 643);
    let v = output.vertices()[205];
    assert!(almost_equal(v.x(), 530.2061647, v.y(), 488.3094489));
    assert_eq!(v.get_incident_edge()?, 645);
    let v = output.vertices()[206];
    assert!(almost_equal(v.x(), 525.7435897, v.y(), 667.0000000));
    assert_eq!(v.get_incident_edge()?, 647);
    let v = output.vertices()[207];
    assert!(almost_equal(v.x(), 531.7220424, v.y(), 487.6142635));
    assert_eq!(v.get_incident_edge()?, 649);
    let v = output.vertices()[208];
    assert!(almost_equal(v.x(), 535.7328635, v.y(), 485.5141895));
    assert_eq!(v.get_incident_edge()?, 651);
    let v = output.vertices()[209];
    assert!(almost_equal(v.x(), 529.5686025, v.y(), 666.8890144));
    assert_eq!(v.get_incident_edge()?, 653);
    let v = output.vertices()[210];
    assert!(almost_equal(v.x(), 560.0000000, v.y(), 262.0000000));
    assert_eq!(v.get_incident_edge()?, 659);
    let v = output.vertices()[211];
    assert!(almost_equal(v.x(), 541.3528746, v.y(), 256.3051731));
    assert_eq!(v.get_incident_edge()?, 661);
    let v = output.vertices()[212];
    assert!(almost_equal(v.x(), 541.7574333, v.y(), 226.6910800));
    assert_eq!(v.get_incident_edge()?, 663);
    let v = output.vertices()[213];
    assert!(almost_equal(v.x(), 536.6438082, v.y(), 215.0486016));
    assert_eq!(v.get_incident_edge()?, 665);
    let v = output.vertices()[214];
    assert!(almost_equal(v.x(), 563.0000000, v.y(), 200.0000000));
    assert_eq!(v.get_incident_edge()?, 669);
    let v = output.vertices()[215];
    assert!(almost_equal(v.x(), 485.9231707, v.y(), 828.7780488));
    assert_eq!(v.get_incident_edge()?, 671);
    let v = output.vertices()[216];
    assert!(almost_equal(v.x(), 567.6011411, v.y(), 191.2656305));
    assert_eq!(v.get_incident_edge()?, 673);
    let v = output.vertices()[217];
    assert!(almost_equal(v.x(), 545.2510903, v.y(), 665.9938109));
    assert_eq!(v.get_incident_edge()?, 681);
    let v = output.vertices()[218];
    assert!(almost_equal(v.x(), 575.9926968, v.y(), 200.6286789));
    assert_eq!(v.get_incident_edge()?, 685);
    let v = output.vertices()[219];
    assert!(almost_equal(v.x(), 543.3512304, v.y(), 561.2273785));
    assert_eq!(v.get_incident_edge()?, 687);
    let v = output.vertices()[220];
    assert!(almost_equal(v.x(), 594.0000000, v.y(), 427.0000000));
    assert_eq!(v.get_incident_edge()?, 695);
    let v = output.vertices()[221];
    assert!(almost_equal(v.x(), 535.5372274, v.y(), 772.4987907));
    assert_eq!(v.get_incident_edge()?, 697);
    let v = output.vertices()[222];
    assert!(almost_equal(v.x(), 567.8763297, v.y(), 407.4540484));
    assert_eq!(v.get_incident_edge()?, 699);
    let v = output.vertices()[223];
    assert!(almost_equal(v.x(), 568.4973753, v.y(), 407.4171139));
    assert_eq!(v.get_incident_edge()?, 701);
    let v = output.vertices()[224];
    assert!(almost_equal(v.x(), 589.6072108, v.y(), 360.7022464));
    assert_eq!(v.get_incident_edge()?, 705);
    let v = output.vertices()[225];
    assert!(almost_equal(v.x(), 612.0000000, v.y(), 209.0000000));
    assert_eq!(v.get_incident_edge()?, 713);
    let v = output.vertices()[226];
    assert!(almost_equal(v.x(), 587.5053351, v.y(), 223.4496521));
    assert_eq!(v.get_incident_edge()?, 715);
    let v = output.vertices()[227];
    assert!(almost_equal(v.x(), 585.8085961, v.y(), 700.3906207));
    assert_eq!(v.get_incident_edge()?, 719);
    let v = output.vertices()[228];
    assert!(almost_equal(v.x(), 585.0828452, v.y(), 277.1877779));
    assert_eq!(v.get_incident_edge()?, 721);
    let v = output.vertices()[229];
    assert!(almost_equal(v.x(), 588.1997608, v.y(), 263.3645046));
    assert_eq!(v.get_incident_edge()?, 723);
    let v = output.vertices()[230];
    assert!(almost_equal(v.x(), 617.0000000, v.y(), 342.0000000));
    assert_eq!(v.get_incident_edge()?, 729);
    let v = output.vertices()[231];
    assert!(almost_equal(v.x(), 587.5644917, v.y(), 272.9572005));
    assert_eq!(v.get_incident_edge()?, 731);
    let v = output.vertices()[232];
    assert!(almost_equal(v.x(), 583.7445960, v.y(), 86.3840693));
    assert_eq!(v.get_incident_edge()?, 733);
    let v = output.vertices()[233];
    assert!(almost_equal(v.x(), 600.3129897, v.y(), 337.4846913));
    assert_eq!(v.get_incident_edge()?, 735);
    let v = output.vertices()[234];
    assert!(almost_equal(v.x(), 618.0000000, v.y(), 281.0000000));
    assert_eq!(v.get_incident_edge()?, 739);
    let v = output.vertices()[235];
    assert!(almost_equal(v.x(), 605.8405676, v.y(), 329.0550585));
    assert_eq!(v.get_incident_edge()?, 741);
    let v = output.vertices()[236];
    assert!(almost_equal(v.x(), 604.3450942, v.y(), 444.8452874));
    assert_eq!(v.get_incident_edge()?, 743);
    let v = output.vertices()[237];
    assert!(almost_equal(v.x(), 629.0000000, v.y(), 758.0000000));
    assert_eq!(v.get_incident_edge()?, 749);
    let v = output.vertices()[238];
    assert!(almost_equal(v.x(), 605.8065278, v.y(), 713.5468718));
    assert_eq!(v.get_incident_edge()?, 751);
    let v = output.vertices()[239];
    assert!(almost_equal(v.x(), 611.8761662, v.y(), 79.9550466));
    assert_eq!(v.get_incident_edge()?, 753);
    let v = output.vertices()[240];
    assert!(almost_equal(v.x(), 608.5858114, v.y(), 657.8731520));
    assert_eq!(v.get_incident_edge()?, 755);
    let v = output.vertices()[241];
    assert!(almost_equal(v.x(), 597.7646129, v.y(), 632.3943898));
    assert_eq!(v.get_incident_edge()?, 757);
    let v = output.vertices()[242];
    assert!(almost_equal(v.x(), 617.1017027, v.y(), 433.2510490));
    assert_eq!(v.get_incident_edge()?, 759);
    let v = output.vertices()[243];
    assert!(almost_equal(v.x(), 616.7589723, v.y(), 598.6600357));
    assert_eq!(v.get_incident_edge()?, 763);
    let v = output.vertices()[244];
    assert!(almost_equal(v.x(), 611.8194939, v.y(), 788.0017794));
    assert_eq!(v.get_incident_edge()?, 765);
    let v = output.vertices()[245];
    assert!(almost_equal(v.x(), 617.1356621, v.y(), 18.1559708));
    assert_eq!(v.get_incident_edge()?, 767);
    let v = output.vertices()[246];
    assert!(almost_equal(v.x(), 628.2103477, v.y(), 184.6844784));
    assert_eq!(v.get_incident_edge()?, 769);
    let v = output.vertices()[247];
    assert!(almost_equal(v.x(), 637.1186829, v.y(), 294.0754211));
    assert_eq!(v.get_incident_edge()?, 771);
    let v = output.vertices()[248];
    assert!(almost_equal(v.x(), 617.1530210, v.y(), 511.8737125));
    assert_eq!(v.get_incident_edge()?, 773);
    let v = output.vertices()[249];
    assert!(almost_equal(v.x(), 670.0000000, v.y(), 175.0000000));
    assert_eq!(v.get_incident_edge()?, 781);
    let v = output.vertices()[250];
    assert!(almost_equal(v.x(), 646.5880885, v.y(), 278.6176593));
    assert_eq!(v.get_incident_edge()?, 785);
    let v = output.vertices()[251];
    assert!(almost_equal(v.x(), 643.0426971, v.y(), 197.6341305));
    assert_eq!(v.get_incident_edge()?, 787);
    let v = output.vertices()[252];
    assert!(almost_equal(v.x(), 645.5275612, v.y(), 206.2060366));
    assert_eq!(v.get_incident_edge()?, 797);
    let v = output.vertices()[253];
    assert!(almost_equal(v.x(), 658.9026767, v.y(), 674.3755423));
    assert_eq!(v.get_incident_edge()?, 799);
    let v = output.vertices()[254];
    assert!(almost_equal(v.x(), 513.9388260, v.y(), 909.7121641));
    assert_eq!(v.get_incident_edge()?, 801);
    let v = output.vertices()[255];
    assert!(almost_equal(v.x(), 645.5000812, v.y(), 395.5163942));
    assert_eq!(v.get_incident_edge()?, 803);
    let v = output.vertices()[256];
    assert!(almost_equal(v.x(), 652.0166959, v.y(), 265.3393672));
    assert_eq!(v.get_incident_edge()?, 805);
    let v = output.vertices()[257];
    assert!(almost_equal(v.x(), 633.6008471, v.y(), -0.5802743));
    assert_eq!(v.get_incident_edge()?, 807);
    let v = output.vertices()[258];
    assert!(almost_equal(v.x(), 497.4615489, v.y(), -154.8528761));
    assert_eq!(v.get_incident_edge()?, 809);
    let v = output.vertices()[259];
    assert!(almost_equal(v.x(), 656.4537249, v.y(), 256.1234352));
    assert_eq!(v.get_incident_edge()?, 811);
    let v = output.vertices()[260];
    assert!(almost_equal(v.x(), 654.4268711, v.y(), 385.2678891));
    assert_eq!(v.get_incident_edge()?, 815);
    let v = output.vertices()[261];
    assert!(almost_equal(v.x(), 657.5904061, v.y(), 367.5499538));
    assert_eq!(v.get_incident_edge()?, 817);
    let v = output.vertices()[262];
    assert!(almost_equal(v.x(), 656.3960797, v.y(), 81.7358432));
    assert_eq!(v.get_incident_edge()?, 819);
    let v = output.vertices()[263];
    assert!(almost_equal(v.x(), 659.9045381, v.y(), 372.5560231));
    assert_eq!(v.get_incident_edge()?, 821);
    let v = output.vertices()[264];
    assert!(almost_equal(v.x(), 688.9125561, v.y(), 308.1385650));
    assert_eq!(v.get_incident_edge()?, 825);
    let v = output.vertices()[265];
    assert!(almost_equal(v.x(), 669.8492433, v.y(), 761.6426077));
    assert_eq!(v.get_incident_edge()?, 827);
    let v = output.vertices()[266];
    assert!(almost_equal(v.x(), 692.8391698, v.y(), 307.6898092));
    assert_eq!(v.get_incident_edge()?, 829);
    let v = output.vertices()[267];
    assert!(almost_equal(v.x(), 681.9032429, v.y(), 604.4690790));
    assert_eq!(v.get_incident_edge()?, 831);
    let v = output.vertices()[268];
    assert!(almost_equal(v.x(), 679.0601012, v.y(), 733.6913900));
    assert_eq!(v.get_incident_edge()?, 833);
    let v = output.vertices()[269];
    assert!(almost_equal(v.x(), 687.4987316, v.y(), 464.8312399));
    assert_eq!(v.get_incident_edge()?, 837);
    let v = output.vertices()[270];
    assert!(almost_equal(v.x(), 689.2098887, v.y(), 141.5844794));
    assert_eq!(v.get_incident_edge()?, 839);
    let v = output.vertices()[271];
    assert!(almost_equal(v.x(), 732.0000000, v.y(), 346.0000000));
    assert_eq!(v.get_incident_edge()?, 845);
    let v = output.vertices()[272];
    assert!(almost_equal(v.x(), 699.6541453, v.y(), 352.0596290));
    assert_eq!(v.get_incident_edge()?, 847);
    let v = output.vertices()[273];
    assert!(almost_equal(v.x(), 692.5352674, v.y(), 364.5042847));
    assert_eq!(v.get_incident_edge()?, 849);
    let v = output.vertices()[274];
    assert!(almost_equal(v.x(), 672.7868069, v.y(), 106.4661106));
    assert_eq!(v.get_incident_edge()?, 853);
    let v = output.vertices()[275];
    assert!(almost_equal(v.x(), 700.1857471, v.y(), 437.8058578));
    assert_eq!(v.get_incident_edge()?, 857);
    let v = output.vertices()[276];
    assert!(almost_equal(v.x(), 694.8607078, v.y(), 459.2594162));
    assert_eq!(v.get_incident_edge()?, 859);
    let v = output.vertices()[277];
    assert!(almost_equal(v.x(), 735.0000000, v.y(), 479.0000000));
    assert_eq!(v.get_incident_edge()?, 863);
    let v = output.vertices()[278];
    assert!(almost_equal(v.x(), 686.3533327, v.y(), 576.5557752));
    assert_eq!(v.get_incident_edge()?, 865);
    let v = output.vertices()[279];
    assert!(almost_equal(v.x(), 674.5199734, v.y(), 99.5932091));
    assert_eq!(v.get_incident_edge()?, 867);
    let v = output.vertices()[280];
    assert!(almost_equal(v.x(), 704.3001872, v.y(), 162.5636748));
    assert_eq!(v.get_incident_edge()?, 869);
    let v = output.vertices()[281];
    assert!(almost_equal(v.x(), 693.1519629, v.y(), 569.1359774));
    assert_eq!(v.get_incident_edge()?, 871);
    let v = output.vertices()[282];
    assert!(almost_equal(v.x(), 701.0929604, v.y(), 561.4185921));
    assert_eq!(v.get_incident_edge()?, 877);
    let v = output.vertices()[283];
    assert!(almost_equal(v.x(), 742.1210191, v.y(), 141.6878981));
    assert_eq!(v.get_incident_edge()?, 883);
    let v = output.vertices()[284];
    assert!(almost_equal(v.x(), 718.1320317, v.y(), 177.5020688));
    assert_eq!(v.get_incident_edge()?, 885);
    let v = output.vertices()[285];
    assert!(almost_equal(v.x(), 711.0000000, v.y(), 81.5412371));
    assert_eq!(v.get_incident_edge()?, 889);
    let v = output.vertices()[286];
    assert!(almost_equal(v.x(), 732.2352217, v.y(), 239.4776595));
    assert_eq!(v.get_incident_edge()?, 891);
    let v = output.vertices()[287];
    assert!(almost_equal(v.x(), 746.3236663, v.y(), 301.3884525));
    assert_eq!(v.get_incident_edge()?, 893);
    let v = output.vertices()[288];
    assert!(almost_equal(v.x(), 754.6099983, v.y(), 337.8022228));
    assert_eq!(v.get_incident_edge()?, 895);
    let v = output.vertices()[289];
    assert!(almost_equal(v.x(), 755.7110972, v.y(), 345.4651632));
    assert_eq!(v.get_incident_edge()?, 897);
    let v = output.vertices()[290];
    assert!(almost_equal(v.x(), 726.4395880, v.y(), 715.4849666));
    assert_eq!(v.get_incident_edge()?, 899);
    let v = output.vertices()[291];
    assert!(almost_equal(v.x(), 726.4620419, v.y(), 715.6335079));
    assert_eq!(v.get_incident_edge()?, 901);
    let v = output.vertices()[292];
    assert!(almost_equal(v.x(), 758.5915076, v.y(), 392.5408492));
    assert_eq!(v.get_incident_edge()?, 905);
    let v = output.vertices()[293];
    assert!(almost_equal(v.x(), 757.1083213, v.y(), 509.0619247));
    assert_eq!(v.get_incident_edge()?, 907);
    let v = output.vertices()[294];
    assert!(almost_equal(v.x(), 752.1265625, v.y(), 88.3250000));
    assert_eq!(v.get_incident_edge()?, 909);
    let v = output.vertices()[295];
    assert!(almost_equal(v.x(), 779.7246659, v.y(), 621.8324053));
    assert_eq!(v.get_incident_edge()?, 911);
    let v = output.vertices()[296];
    assert!(almost_equal(v.x(), 836.1811616, v.y(), 476.7177182));
    assert_eq!(v.get_incident_edge()?, 913);
    let v = output.vertices()[297];
    assert!(almost_equal(v.x(), 620.3654971, v.y(), 1095.6578947));
    assert_eq!(v.get_incident_edge()?, 915);
    let v = output.vertices()[298];
    assert!(almost_equal(v.x(), 856.8056769, v.y(), 592.5611354));
    assert_eq!(v.get_incident_edge()?, 917);
    let v = output.vertices()[299];
    assert!(almost_equal(v.x(), 867.2333166, v.y(), 493.8138485));
    assert_eq!(v.get_incident_edge()?, 919);
    let v = output.vertices()[300];
    assert!(almost_equal(v.x(), 711.0000000, v.y(), -690.1363636));
    assert_eq!(v.get_incident_edge()?, 921);
    let v = output.vertices()[301];
    assert!(almost_equal(v.x(), 1101.4076456, v.y(), 554.6383495));
    assert_eq!(v.get_incident_edge()?, 923);
    let v = output.vertices()[302];
    assert!(almost_equal(v.x(), 521.6624933, v.y(), 2145.4989345));
    assert_eq!(v.get_incident_edge()?, 925);
    let v = output.vertices()[303];
    assert!(almost_equal(v.x(), 516.6056696, v.y(), 2285.5729527));
    assert_eq!(v.get_incident_edge()?, 927);
    Ok(())
}