with t (x1, x2, c) as
(
select 1, 4, 'red' from dual
union all select 7, 10, 'red' from dual
union all select 13, 16, 'red' from dual
union all select 3, 14, 'black' from dual
union all select 16, 19, 'black' from dual
union all select 18, 22, 'red' from dual
union all select 22, 25, 'black' from dual
union all select 26, 28, 'red' from dual
union all select 29, 30, 'black' from dual
union all select 32, 33, 'black' from dual
)
select ...
/

        X1         X2 RESULT
---------- ---------- -------
         1          2 red
         3          4 overlap
         5          6 black
         7         10 overlap
        11         12 black
        13         14 overlap
        15         15 red
        16         16 overlap
        17         17 black
        18         19 overlap
        20         21 red
        22         22 overlap
        23         25 black
        26         28 red
        29         30 black
        31         31 none
        32         33 black

17 rows selected.

select x1, x2, result
from t unpivot (x for type in (x1, x2))
match_recognize
(
  order by x, type
  measures
    case when type = 'X2' and next(type) = 'X1' and next(x) - x =1 then 1 end touch,
    case when next(x) = x and next(type) = type then 1 end same_bound,
    x + decode(type, 'X2', 1, 0) x1,
    next(x) - decode(next(type), 'X1', 1, 0) x2,
    decode(sum(decode(c, 'red', 1, 'black', 2) * decode(type, 'X1', 1, 'X2', -1)),
           1, 'red', 2, 'black', 3, 'overlap', 'none') result    
  all rows per match
  pattern (x+)
  define x as next(x) is not null
)
where touch is null and same_bound is null

with t (x1, x2, c, flag) as
(
select 1, 4, 'red', 'src' from dual
union all select 7, 10, 'yellow', 'src' from dual
union all select 13, 16, 'red', 'src' from dual
--union all select 3, 14, 'black' from dual
union all select 3, 7, 'black', 'tgt' from dual
union all select 9, 11, 'black', 'tgt' from dual
union all select 13, 14, 'black', 'tgt' from dual
--
union all select 16, 19, 'blue', 'tgt' from dual
union all select 18, 22, 'green', 'src' from dual
union all select 22, 25, 'black', 'tgt' from dual
union all select 26, 28, 'red', 'src' from dual
union all select 29, 30, 'red', 'tgt' from dual
union all select 32, 33, 'black', 'tgt' from dual
)
select ...
/

        X1         X2 RESULT
---------- ---------- ------
         1          4 red
         5          6 black
         7         10 yellow
        11         11 black
        12         12
        13         16 red
        17         17 blue
        18         22 green
        23         25 black
        26         30 red
        31         31
        32         33 black

12 rows selected.

select x1 as x, decode(c, 'red', 1, 0), decode(c, 'black', 1, 0) from t
union all
select x2 + 1 as x, decode(c, 'red', -1, 0), decode(c, 'black', -1, 0) from t

range unbounded preceding

keep (dense_rank first order by x)

nvl(decode(src_active, 1, src_c), decode(tgt_active, 1, tgt_c))

, tt as
(
select x1,
       nvl(decode(src_active, 1, src_c), decode(tgt_active, 1, tgt_c)) result,
       lag(nvl(decode(src_active, 1, src_c), decode(tgt_active, 1, tgt_c))) over(order by x1) prev_result
  from (select x1,
               sum(decode(flag, 'src', sign)) over(order by x1, type) src_active,
               sum(decode(flag, 'tgt', sign)) over(order by x1, type) tgt_active,
               last_value(decode(flag, 'src', c) ignore nulls) over(order by x1, type) src_c,
               last_value(decode(flag, 'tgt', c) ignore nulls) over(order by x1, type) tgt_c
          from (select c,
                       flag,
                       type,
                       x + decode(type, 'X2', 1, 0) x1,
                       decode(type, 'X1', 1, 'X2', -1) sign
                  from t unpivot(x for type in(x1, x2)))) t
)
select *
  from (select min(x1) x1,
               lead(min(x1)) over(order by grp) - 1 x2,
               min(result) result
          from (select tt.*, sum(decode(result, prev_result, 0, 1)) over(order by x1) grp from tt)
         group by grp)
 where x2 is not null

select min(n) x1, max(n) x2, result
  from (select t.*,
               n - row_number() over(partition by result order by n) grp
          from (select t.*,
                       nvl((select max(c) from t where flag = 'src' and n between x1 and x2),
                           (select max(c) from t where flag = 'tgt' and n between x1 and x2)) result
                  from nums t) t)
 group by result, grp
 order by 1

select *
  from
(
select x1,
       nvl(decode(src_active, 1, src_c), decode(tgt_active, 1, tgt_c)) result
  from (select x1,
               sum(decode(flag, 'src', sign)) over(order by x1, type) src_active,
               sum(decode(flag, 'tgt', sign)) over(order by x1, type) tgt_active,
               last_value(decode(flag, 'src', c) ignore nulls) over(order by x1, type) src_c,
               last_value(decode(flag, 'tgt', c) ignore nulls) over(order by x1, type) tgt_c
          from (select c,
                       flag,
                       type,
                       x + decode(type, 'X2', 1, 0) x1,
                       decode(type, 'X1', 1, 'X2', -1) sign
                  from t unpivot(x for type in(x1, x2)))) t
)
match_recognize
(
  order by x1
  measures
    first(x.x1) x1,
    next(x.x1) - 1 x2,
    x.result result
  pattern (x+)
  define
    x as first(nvl(result, '~')) = nvl(result, '~') and next(x1) is not null
)