How to bridge (fill) gaps when converting a 2006 geometry into a 2002 geometry

Question

Is it at all possible to bridge (fill) gaps when converting a 2006 geometry into a single 2002 geometry. I have a solution for the conversion from 2006 to 2002 provided by BHall but upon further investigation investigation of my dataset some of the multi line polygons have gaps which I need to fill and I am not sure how to go about this.
Here is a simple example of what I am trying to achieve
Before
SELECT (sdo_geometry(2006, 81989, NULL,
                mdsys.sdo_elem_info_array(1,2,1,5,2,1,9,2,1,13,2,1),
                mdsys.sdo_ordinate_array(16,0.999,16.998,-0.001,17.253,-0.001,18.003,0.999,18.003,0.999,19.001,0.999,19.001,0.999,19.999,-0.001)))
  FROM dual
After
SELECT (sdo_geometry(2006, 81989,NULL,
               mdsys.sdo_elem_info_array(1,2,1),
               mdsys.sdo_ordinate_array(16,0.999,17.253,-0.001,18.003,0.999,19.001,0.999,19.999,-0.001))) FROM dual    
Thanks in advance

Answer 1

Okay Roché,
You might need to break this problem down into smaller parts for the forum.  All your examples show the gap being replaced by a single vertice - e.g. you want to "snap" the gap together.  I'd suggest this is just complicating your question.  Once the gap is filled (with a line) then you can run SDO_UTIL.REMOVE_DUPLICATE_VERTICES afterwards to remove the new line if its below your tolerance.  I think that Bryan's code wrapped in remove duplicate vertices will solve your second scenario.  But overall I think it would be helpful to focus just on the filling and leave the snapping for a follow-up question.
So back to scenario #1, below is some code I wrote a while back that might do what you want or at least get you started.     Note that the input must be a multistring and the multistring cannot be "spaghetti".  In other words each line in the multistring must be disjoint or at most touch other lines only at endpoints. The goal is to sift through the lines and create a single linestring using the smallest gaps.  It's not subtle and will indeed produce bad geometries if the inputs are setup in an impossible manner.  There are also some rare geodetic bugs with SDO_GEOM.RELATE that crop up.  So you'll note I test both distance and relate in some places.  That's intentional though kind of dumb.
Hopefully this helps.  If you improve the code please shoot a copy back to me.
Cheers,
Paul   
CREATE OR REPLACE PACKAGE dz_gap_fill
AUTHID CURRENT_USER
AS
   FUNCTION linear_gap_filler(
       p_input            IN  MDSYS.SDO_GEOMETRY
      ,p_tolerance        IN  NUMBER DEFAULT 0.05
   ) RETURN MDSYS.SDO_GEOMETRY;
END dz_gap_fill;
CREATE OR REPLACE PACKAGE BODY dz_gap_fill
AS
   FUNCTION fast_point(
       p_x             IN  NUMBER
      ,p_y             IN  NUMBER
      ,p_z             IN  NUMBER DEFAULT NULL
      ,p_m             IN  NUMBER DEFAULT NULL
      ,p_srid          IN  NUMBER DEFAULT 8265
   ) RETURN MDSYS.SDO_GEOMETRY
   AS
   BEGIN
      -- Step 10
      -- Check over incoming parameters
      IF p_x IS NULL
      OR p_y IS NULL
      THEN
         RAISE_APPLICATION_ERROR(-20001,'x and y cannot be NULL');
      END IF;
      -- Step 20
      -- Do the simplest solution first
      IF  p_z IS NULL
      AND p_m IS NULL
      THEN
         RETURN SDO_GEOMETRY(
             2001
            ,p_srid
            ,SDO_POINT_TYPE(
                 p_x
                ,p_y
                ,NULL
            ,NULL
            ,NULL
      END IF;
      -- Step 30
      -- Do the other wilder choices
      IF p_z IS NULL
      AND p_m IS NOT NULL
      THEN
         RETURN SDO_GEOMETRY(
             3301
            ,p_srid
            ,SDO_POINT_TYPE(
                 p_x
                ,p_y
                ,p_m
            ,NULL
            ,NULL
      ELSIF p_z IS NOT NULL
      AND   p_m IS NULL
      THEN
         RETURN SDO_GEOMETRY(
             3001
            ,p_srid
            ,SDO_POINT_TYPE(
                 p_x
                ,p_y
                ,p_z
            ,NULL
            ,NULL
      ELSIF p_z IS NOT NULL
      AND   p_m IS NOT NULL
      THEN
         RETURN SDO_GEOMETRY(
             4401
            ,p_srid
            ,NULL
            ,SDO_ELEM_INFO_ARRAY(1,1,1)
            ,SDO_ORDINATE_ARRAY(p_x,p_y,p_z,p_m)
      ELSE
         RAISE_APPLICATION_ERROR(-20001,'ERR!');
      END IF;
   END fast_point;
   FUNCTION get_start_point(
      p_input        IN  MDSYS.SDO_GEOMETRY
   ) RETURN MDSYS.SDO_GEOMETRY
   AS
      int_dims PLS_INTEGER;
      int_gtyp PLS_INTEGER;
      int_lrs  PLS_INTEGER;
   BEGIN
      -- Step 10
      -- Check over incoming parameters
      IF p_input IS NULL
      THEN
         RETURN NULL;
      END IF;
      -- Step 20
      -- Gather information about the geometry
      int_dims := p_input.get_dims();
      int_gtyp := p_input.get_gtype();
      int_lrs  := p_input.get_lrs_dim();
      -- Step 30
      -- Handle point and multipoint inputs
      IF int_gtyp = 1
      THEN
         RETURN p_input;
      ELSIF int_gtyp = 5
      THEN
         RETURN SDO_UTIL.EXTRACT(p_input,1);
      END IF;
      -- Step 40
      -- Return results
      IF int_dims = 2
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(1)
            ,p_input.SDO_ORDINATES(2)
            ,NULL
            ,NULL
            ,p_input.SDO_SRID
      ELSIF  int_dims = 3
      AND int_lrs = 3
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(1)
            ,p_input.SDO_ORDINATES(2)
            ,NULL
            ,p_input.SDO_ORDINATES(3)
            ,p_input.SDO_SRID
      ELSIF  int_dims = 3
      AND int_lrs = 0
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(1)
            ,p_input.SDO_ORDINATES(2)
            ,p_input.SDO_ORDINATES(3)
            ,NULL
            ,p_input.SDO_SRID
      ELSIF  int_dims = 4
      AND int_lrs IN (4,0)
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(1)
            ,p_input.SDO_ORDINATES(2)
            ,p_input.SDO_ORDINATES(3)
            ,p_input.SDO_ORDINATES(4)
            ,p_input.SDO_SRID
      ELSIF  int_dims = 4
      AND int_lrs = 3
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(1)
            ,p_input.SDO_ORDINATES(2)
            ,p_input.SDO_ORDINATES(4)
            ,p_input.SDO_ORDINATES(3)
            ,p_input.SDO_SRID
      ELSE
         RAISE_APPLICATION_ERROR(-20001,'ERR!');
      END IF;
   END get_start_point;
   FUNCTION get_end_point(
      p_input        IN  MDSYS.SDO_GEOMETRY
   ) RETURN MDSYS.SDO_GEOMETRY
   AS
      int_dims PLS_INTEGER;
      int_gtyp PLS_INTEGER;
      int_lrs  PLS_INTEGER;
      int_len  PLS_INTEGER;
   BEGIN
      -- Step 10
      -- Check over incoming parameters
      IF p_input IS NULL
      THEN
         RETURN NULL;
      END IF;
      -- Step 20
      -- Gather information about the geometry
      int_dims := p_input.get_dims();
      int_gtyp := p_input.get_gtype();
      int_lrs  := p_input.get_lrs_dim();
      int_len  := p_input.SDO_ORDINATES.COUNT();
      -- Step 30
      -- Handle point and multipoint inputs
      IF int_gtyp = 1
      THEN
         RETURN p_input;
      ELSIF int_gtyp = 5
      THEN
         RETURN SDO_UTIL.EXTRACT(
             p_input
            ,SDO_UTIL.GETNUMELEM(p_input)
      END IF;
      -- Step 40
      -- Return results
      IF int_dims = 2
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(int_len - 1)
            ,p_input.SDO_ORDINATES(int_len)
            ,NULL
            ,NULL
            ,p_input.SDO_SRID
      ELSIF  int_dims = 3
      AND int_lrs = 3
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(int_len - 2)
            ,p_input.SDO_ORDINATES(int_len - 1)
            ,NULL
            ,p_input.SDO_ORDINATES(int_len)
            ,p_input.SDO_SRID
      ELSIF  int_dims = 3
      AND int_lrs = 0
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(int_len - 2)
            ,p_input.SDO_ORDINATES(int_len - 1)
            ,p_input.SDO_ORDINATES(int_len)
            ,NULL
            ,p_input.SDO_SRID
      ELSIF  int_dims = 4
      AND int_lrs IN (4,0)
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(int_len - 3)
            ,p_input.SDO_ORDINATES(int_len - 2)
            ,p_input.SDO_ORDINATES(int_len - 1)
            ,p_input.SDO_ORDINATES(int_len)
            ,p_input.SDO_SRID
      ELSIF  int_dims = 4
      AND int_lrs = 3
      THEN
         RETURN fast_point(
             p_input.SDO_ORDINATES(int_len - 3)
            ,p_input.SDO_ORDINATES(int_len - 2)
            ,p_input.SDO_ORDINATES(int_len)
            ,p_input.SDO_ORDINATES(int_len - 1)
            ,p_input.SDO_SRID
      ELSE
         RAISE_APPLICATION_ERROR(-20001,'ERR!');
      END IF;
   END get_end_point;
   FUNCTION is_spaghetti(
       p_input             IN  MDSYS.SDO_GEOMETRY
      ,p_tolerance         IN  NUMBER DEFAULT 0.05
   ) RETURN VARCHAR2
   AS
      num_tolerance    NUMBER := p_tolerance;
      ary_strings      MDSYS.SDO_GEOMETRY_ARRAY := MDSYS.SDO_GEOMETRY_ARRAY();
      ary_starts       MDSYS.SDO_GEOMETRY_ARRAY := MDSYS.SDO_GEOMETRY_ARRAY();
      ary_ends         MDSYS.SDO_GEOMETRY_ARRAY := MDSYS.SDO_GEOMETRY_ARRAY();
      int_count        PLS_INTEGER;
      ary_start_count  MDSYS.SDO_NUMBER_ARRAY := MDSYS.SDO_NUMBER_ARRAY();
      ary_end_count    MDSYS.SDO_NUMBER_ARRAY := MDSYS.SDO_NUMBER_ARRAY();
      ary_inside_count MDSYS.SDO_NUMBER_ARRAY := MDSYS.SDO_NUMBER_ARRAY();
   BEGIN
      -- Step 10
      -- Check over incoming parameters
      IF p_input IS NULL
      THEN
         RETURN NULL;
      ELSIF p_input.get_gtype = 2
      THEN
         RETURN 'FALSE';
      ELSIF p_input.get_gtype <> 6
      THEN
         RAISE_APPLICATION_ERROR(-20001,'input gtype must be 2 or 6');
      END IF;
      IF num_tolerance IS NULL
      THEN
         num_tolerance := 0.05;
      END IF;
      -- Step 20
      -- Break multistring into single linestrings with nodes
      int_count := SDO_UTIL.GETNUMELEM(p_input);
      ary_strings.EXTEND(int_count);
      ary_starts.EXTEND(int_count);
      ary_ends.EXTEND(int_count);
      ary_start_count.EXTEND(int_count);
      ary_end_count.EXTEND(int_count);
      ary_inside_count.EXTEND(int_count);
      FOR i IN 1 .. int_count
      LOOP
         ary_strings(i) := SDO_UTIL.EXTRACT(p_input,i);
         ary_starts(i)  := get_start_point(ary_strings(i));
         ary_ends(i)    := get_end_point(ary_strings(i));
      END LOOP;
      -- Step 30
      -- Loop through and count the nodes connections
      FOR i IN 1 .. int_count
      LOOP
         ary_start_count(i)  := 0;
         ary_end_count(i)    := 0;
         ary_inside_count(i) := 0;
         FOR j IN 1 .. int_count
         LOOP
            IF i != j
            THEN
               IF SDO_GEOM.RELATE(
                  ary_starts(i),
                  'DETERMINE',
                  ary_strings(j),
                  num_tolerance
               ) IN ('TOUCH','CONTAINS','COVERS','ON')
               THEN
                  ary_start_count(i) := ary_start_count(i) + 1;
               ELSIF SDO_GEOM.RELATE(
                  ary_ends(i),
                  'DETERMINE',
                  ary_strings(j),
                  num_tolerance
               ) IN ('TOUCH','CONTAINS','COVERS','ON')
               THEN
                  ary_end_count(i) := ary_end_count(i) + 1;
               ELSIF SDO_GEOM.RELATE(
                  ary_strings(i),
                  'DETERMINE',
                  ary_strings(j),
                  num_tolerance
               ) IN ('TOUCH','CONTAINS','COVERS','OVERLAPBYINTERSECT')
               THEN
                  ary_inside_count(i) := ary_inside_count(i) + 1;
               END IF;
            END IF;
         END LOOP;
         IF ary_start_count(i) > 1
         OR ary_end_count(i) > 1
         OR ary_inside_count(i) > 0
         THEN
            RETURN 'TRUE';
         END IF;
      END LOOP;
      RETURN 'FALSE';
   END is_spaghetti;
   FUNCTION points2segment(
       p_point_one              IN  MDSYS.SDO_POINT_TYPE
      ,p_point_two              IN  MDSYS.SDO_POINT_TYPE
      ,p_srid                   IN  NUMBER
   ) RETURN MDSYS.SDO_GEOMETRY
   AS
   BEGIN
      IF ( p_point_one.Z IS NULL AND p_point_two.Z IS NOT NULL )
      OR ( p_point_one.Z IS NOT NULL AND p_point_two.Z IS NULL )
      THEN
         RAISE_APPLICATION_ERROR(
            -20001,
            'both points must have the same number of dimensions, point_one Z is ' ||
            NVL(TO_CHAR(p_point_one.Z),'') ||
            ' and point_two Z is ' ||
            NVL(TO_CHAR(p_point_two.Z),'')
      END IF;
      IF p_point_one.Z IS NULL
      THEN
         RETURN SDO_GEOMETRY(
             2002
            ,p_srid
            ,NULL
            ,SDO_ELEM_INFO_ARRAY(1,2,1)
            ,SDO_ORDINATE_ARRAY(p_point_one.X,p_point_one.Y,p_point_two.X,p_point_two.Y)
      ELSE
         RETURN SDO_GEOMETRY(
             3002
            ,p_srid
            ,NULL
            ,SDO_ELEM_INFO_ARRAY(1,2,1)
            ,SDO_ORDINATE_ARRAY(p_point_one.X,p_point_one.Y,p_point_one.Z,p_point_two.X,p_point_two.Y,p_point_two.Z)
      END IF;
   END points2segment;
   FUNCTION points2segment(
       p_point_one              IN  MDSYS.SDO_GEOMETRY
      ,p_point_two              IN  MDSYS.SDO_GEOMETRY
   ) RETURN MDSYS.SDO_GEOMETRY
   AS
      int_gtype1 PLS_INTEGER;
      int_dims1  PLS_INTEGER;
      int_gtype2 PLS_INTEGER;
      int_dims2  PLS_INTEGER;
      point_one  MDSYS.SDO_POINT_TYPE;
      point_two  MDSYS.SDO_POINT_TYPE;
   BEGIN
      int_gtype1 := p_point_one.get_gtype();
      int_dims1  := p_point_one.get_dims();
      int_gtype2 := p_point_two.get_gtype();
      int_dims2  := p_point_two.get_dims();
      IF  int_gtype1 = 1
      AND int_gtype2 = 1
      AND int_dims1  = int_dims2
      AND p_point_one.SDO_SRID = p_point_two.SDO_SRID
      THEN
         NULL;  -- Good
      ELSE
         RAISE_APPLICATION_ERROR(
             -20001
            ,'both point objects must be points and have the same number of dimensions and SRIDs'
      END IF;
      IF int_dims1 = 4
      THEN
         RETURN SDO_GEOMETRY(
             4402
            ,p_point_one.SDO_SRID
            ,NULL
            ,SDO_ELEM_INFO_ARRAY(1,2,1)
            ,SDO_ORDINATE_ARRAY(
                 p_point_one.SDO_ORDINATES(1)
                ,p_point_one.SDO_ORDINATES(2)
                ,p_point_one.SDO_ORDINATES(3)
                ,p_point_one.SDO_ORDINATES(4)
                ,p_point_two.SDO_ORDINATES(1)
                ,p_point_two.SDO_ORDINATES(2)
                ,p_point_two.SDO_ORDINATES(3)
                ,p_point_two.SDO_ORDINATES(4)
      ELSE
         -- Use the sdo_point_type method for the rest
         IF p_point_one.SDO_POINT IS NOT NULL
         THEN
            point_one := p_point_one.SDO_POINT;
         ELSE
            IF int_dims1 = 3
            THEN
               point_one := SDO_POINT_TYPE(
                   p_point_one.SDO_ORDINATES(1)
                  ,p_point_one.SDO_ORDINATES(2)
                  ,p_point_one.SDO_ORDINATES(3)
            ELSE
               point_one := SDO_POINT_TYPE(
                   p_point_one.SDO_ORDINATES(1)
                  ,p_point_one.SDO_ORDINATES(2)
                  ,NULL
            END IF;
         END IF;
         IF p_point_two.SDO_POINT IS NOT NULL
         THEN
            point_two := p_point_two.SDO_POINT;
         ELSE
            IF int_dims1 = 3
            THEN
               point_two := SDO_POINT_TYPE(
                    p_point_two.SDO_ORDINATES(1)
                   ,p_point_two.SDO_ORDINATES(2)
                   ,p_point_two.SDO_ORDINATES(3)
            ELSE
               point_two := SDO_POINT_TYPE(
                   p_point_two.SDO_ORDINATES(1)
                  ,p_point_two.SDO_ORDINATES(2)
                  ,NULL
            END IF;
         END IF;
         RETURN points2segment(
             p_point_one   => point_one
            ,p_point_two   => point_two
            ,p_srid        => p_point_one.SDO_SRID
      END IF;
   END points2segment;
   FUNCTION linear_gap_filler(
       p_input            IN  MDSYS.SDO_GEOMETRY
      ,p_tolerance        IN  NUMBER DEFAULT 0.05
   ) RETURN MDSYS.SDO_GEOMETRY
   AS
      sdo_input     MDSYS.SDO_GEOMETRY := p_input;
      num_tolerance NUMBER;
      int_counter   PLS_INTEGER;
      ary_edges     MDSYS.SDO_GEOMETRY_ARRAY;
      ary_starts    MDSYS.SDO_GEOMETRY_ARRAY;
      ary_ends      MDSYS.SDO_GEOMETRY_ARRAY;
      ary_nearest   MDSYS.SDO_NUMBER_ARRAY;
      ary_distance  MDSYS.SDO_NUMBER_ARRAY;
      num_temp      NUMBER;
      num_nearest   NUMBER;
      int_winner    PLS_INTEGER;
      int_winner2   PLS_INTEGER;
      sdo_point1    MDSYS.SDO_GEOMETRY;
      sdo_point2    MDSYS.SDO_GEOMETRY;
      boo_done      BOOLEAN;
      num_one       NUMBER;
      num_two       NUMBER;
      int_looper    PLS_INTEGER := 1;
   BEGIN
      -- Step 10
      -- Check over incoming parameters
      IF num_tolerance IS NULL
      THEN
         num_tolerance := 0.05;
      END IF;
      IF sdo_input IS NULL
      OR sdo_input.get_gtype() <> 6
      THEN
         RETURN sdo_input;
      END IF;
      IF is_spaghetti(sdo_input,p_tolerance) = 'TRUE'
      THEN
         RETURN sdo_input;
      END IF;
      <>      ary_edges     := MDSYS.SDO_GEOMETRY_ARRAY();
      ary_starts    := MDSYS.SDO_GEOMETRY_ARRAY();
      ary_ends      := MDSYS.SDO_GEOMETRY_ARRAY();
      ary_nearest   := MDSYS.SDO_NUMBER_ARRAY();
      ary_distance  := MDSYS.SDO_NUMBER_ARRAY();
      -- Step 20
      -- Break multistring into edges and start and end nodes
      int_counter := SDO_UTIL.GETNUMELEM(sdo_input);     
      ary_edges.EXTEND(int_counter);
      ary_starts.EXTEND(int_counter);
      ary_ends.EXTEND(int_counter);
      FOR i IN 1 .. int_counter
      LOOP 
         ary_edges(i)  := SDO_UTIL.EXTRACT(sdo_input,i);
         ary_starts(i) := get_start_point(ary_edges(i));
         ary_ends(i)   := get_end_point(ary_edges(i));
      END LOOP;
      -- Step 30
      -- Determine the closest endpoints
      ary_nearest.EXTEND(int_counter);
      ary_distance.EXTEND(int_counter);
      FOR i IN 1 .. int_counter
      LOOP
         num_nearest := NULL;
         int_winner := NULL;
         FOR j IN 1 .. int_counter
         LOOP
            IF j != i
            THEN
               num_temp := SDO_GEOM.SDO_DISTANCE(
                   ary_edges(i)
                  ,ary_edges(j)
                  ,num_tolerance
               IF num_nearest IS NULL
               OR num_temp < num_nearest
               THEN
                  num_nearest := num_temp;
                  int_winner := j;
               END IF;
            END IF;
         END LOOP;
         ary_nearest(i) := int_winner;
         ary_distance(i) := num_nearest;
      END LOOP;
      -- Step 40
      -- Find the smallest gap
      int_winner := NULL;
      num_nearest := NULL;
      FOR i IN 1 .. int_counter
      LOOP
         IF num_nearest IS NULL
         OR ary_distance(i) < num_nearest
         THEN
             int_winner := i;
             num_nearest := ary_distance(i);
             int_winner2 := ary_nearest(i);
         END IF;
      END LOOP;
      -- Step 50
      -- Determine the endpoints to connect
      num_one := SDO_GEOM.SDO_DISTANCE(
         get_start_point(ary_edges(int_winner)),
         ary_edges(int_winner2),
         num_tolerance
      num_two := SDO_GEOM.SDO_DISTANCE(
         get_end_point(ary_edges(int_winner)),
         ary_edges(int_winner2),
         num_tolerance
      IF ( num_one = 0 AND SDO_GEOM.RELATE(
         get_start_point(ary_edges(int_winner)),
         'ANYINTERACT',
         ary_edges(int_winner2),
         num_tolerance
      ) = 'TRUE' )
      OR ( num_two = 0 AND SDO_GEOM.RELATE(
         get_end_point(ary_edges(int_winner)),
         'ANYINTERACT',
         ary_edges(int_winner2),
         num_tolerance
      ) = 'TRUE' )
      THEN
         sdo_point1 := NULL;
      ELSIF num_one < num_two
      THEN
         sdo_point1 := get_start_point(ary_edges(int_winner));
      ELSE
         sdo_point1 := get_end_point(ary_edges(int_winner));
      END IF;
      num_one := SDO_GEOM.SDO_DISTANCE(
         get_start_point(ary_edges(int_winner2)),
         ary_edges(int_winner),
         num_tolerance
      num_two := SDO_GEOM.SDO_DISTANCE(
         get_end_point(ary_edges(int_winner2)),
         ary_edges(int_winner),
         num_tolerance
      IF ( num_one = 0 AND SDO_GEOM.RELATE(
         get_start_point(ary_edges(int_winner2)),
         'ANYINTERACT',
         ary_edges(int_winner),
         num_tolerance
      ) = 'TRUE' )
      OR ( num_two = 0 AND SDO_GEOM.RELATE(
         get_end_point(ary_edges(int_winner2)),
         'ANYINTERACT',
         ary_edges(int_winner),
         num_tolerance
      ) = 'TRUE' )
      THEN
         sdo_point2 := NULL;
      ELSIF num_one < num_two
      THEN
         sdo_point2 := get_start_point(ary_edges(int_winner2));
      ELSE
         sdo_point2 := get_end_point(ary_edges(int_winner2));
      END IF;
      -- Step 50
      -- Smash together
      IF sdo_point1 IS NULL
      OR sdo_point2 IS NULL
      THEN
         sdo_input := SDO_UTIL.CONCAT_LINES(
            ary_edges(int_winner),
            ary_edges(int_winner2)
      ELSE
         sdo_input := SDO_UTIL.CONCAT_LINES(
            SDO_UTIL.CONCAT_LINES(
               ary_edges(int_winner),
               points2segment(sdo_point1,sdo_point2)
            ary_edges(int_winner2)
      END IF;
      boo_done := TRUE;
      FOR i IN 1 .. int_counter
      LOOP
         IF i NOT IN (int_winner,int_winner2)
         THEN
            sdo_input := SDO_UTIL.APPEND(sdo_input,ary_edges(i));
            boo_done := FALSE;
         END IF;
      END LOOP;
      -- Step 60
      -- Check if valid if returning
      IF sdo_input.get_gtype() = 2
      OR boo_done = TRUE
      THEN
         RETURN sdo_input;
      END IF;
      int_looper := int_looper + 1;
      GOTO TOP_OF_IT;
   END linear_gap_filler;
END dz_gap_fill;