modules/tests/src/test/resources/testxml/general/TestFunctionLA.xml

<run>
  <precisionModel scale="1.0" offsetx="0.0" offsety="0.0"/>

<case>
  <desc>LA - A and B simple</desc>
  <a>
    LINESTRING(240 190, 120 120)
  </a>
  <b>
    POLYGON(
      (110 240, 50 80, 240 70, 110 240))
  </b>
<test>
  <op name="intersection" arg1="A" arg2="B">
    LINESTRING(177 153, 120 120)
  </op>
</test>
<test>
  <op name="union" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(240 190, 177 153), 
      POLYGON(
        (177 153, 240 70, 50 80, 110 240, 177 153)))
  </op>
</test>
<test>
  <op name="difference" arg1="A" arg2="B">
    LINESTRING(240 190, 177 153)
  </op>
</test>
<test>
  <op name="symdifference" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(240 190, 177 153), 
      POLYGON(
        (177 153, 240 70, 50 80, 110 240, 177 153)))
  </op>
</test>
</case>

<case>
  <desc>LA - A intersects B-hole</desc>
  <a>
    LINESTRING(0 100, 100 100, 200 200)
  </a>
  <b>
    POLYGON(
      (30 240, 260 30, 30 30, 30 240), 
      (80 140, 80 80, 140 80, 80 140))
  </b>
<test>
  <op name="intersection" arg1="A" arg2="B">
    MULTILINESTRING(
      (30 100, 80 100), 
      (110 110, 140 140))
  </op>
</test>
<test>
  <op name="union" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(0 100, 30 100), 
      LINESTRING(80 100, 100 100, 110 110), 
      LINESTRING(140 140, 200 200), 
      POLYGON(
        (30 240, 140 140, 260 30, 30 30, 30 100, 30 240), 
        (80 140, 80 100, 80 80, 140 80, 110 110, 80 140)))
  </op>
</test>
<test>
  <op name="difference" arg1="A" arg2="B">
    MULTILINESTRING(
      (0 100, 30 100), 
      (80 100, 100 100, 110 110), 
      (140 140, 200 200))
  </op>
</test>
<test>
  <op name="symdifference" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(0 100, 30 100), 
      LINESTRING(80 100, 100 100, 110 110), 
      LINESTRING(140 140, 200 200), 
      POLYGON(
        (30 240, 140 140, 260 30, 30 30, 30 100, 30 240), 
        (80 140, 80 100, 80 80, 140 80, 110 110, 80 140)))
  </op>
</test>
</case>

<case>
  <desc>LA - A intersects B-hole #2</desc>
  <a>
    LINESTRING(40 340, 200 250, 120 180, 160 110, 270 40)
  </a>
  <b>
    POLYGON(
      (160 330, 60 260, 20 150, 60 40, 190 20, 270 130, 260 250, 160 330), 
      (140 240, 80 190, 90 100, 160 70, 210 130, 210 210, 140 240))
  </b>
<test>
  <op name="intersection" arg1="A" arg2="B">
    MULTILINESTRING(
      (114 298, 200 250, 173 226), 
      (182 96, 225 68))
  </op>
</test>
<test>
  <op name="union" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(40 340, 114 298), 
      LINESTRING(173 226, 120 180, 160 110, 182 96), 
      LINESTRING(225 68, 270 40), 
      POLYGON(
        (114 298, 160 330, 260 250, 270 130, 225 68, 190 20, 60 40, 20 150, 60 260, 
        114 298), 
        (140 240, 80 190, 90 100, 160 70, 182 96, 210 130, 210 210, 173 226, 140 240)))
  </op>
</test>
<test>
  <op name="difference" arg1="A" arg2="B">
    MULTILINESTRING(
      (40 340, 114 298), 
      (173 226, 120 180, 160 110, 182 96), 
      (225 68, 270 40))
  </op>
</test>
<test>
  <op name="symdifference" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(40 340, 114 298), 
      LINESTRING(173 226, 120 180, 160 110, 182 96), 
      LINESTRING(225 68, 270 40), 
      POLYGON(
        (114 298, 160 330, 260 250, 270 130, 225 68, 190 20, 60 40, 20 150, 60 260, 
        114 298), 
        (140 240, 80 190, 90 100, 160 70, 182 96, 210 130, 210 210, 173 226, 140 240)))
  </op>
</test>
</case>

<case>
  <desc>mLmA - A and B complex, disjoint</desc>
  <a>
    MULTIPOLYGON(
      (
        (60 320, 60 80, 300 80, 60 320), 
        (80 280, 80 100, 260 100, 80 280)), 
      (
        (120 160, 140 160, 140 140, 120 160)))
  </a>
  <b>
    MULTILINESTRING(
      (100 240, 100 180, 160 180, 160 120, 220 120), 
      (40 360, 40 60, 340 60, 40 360, 40 20), 
      (120 120, 120 140, 100 140, 100 120, 140 120))
  </b>
<test>
  <op name="convexhull" pattern="FFFFFFFFF" arg1="A">
    POLYGON(
      (60 80, 60 320, 300 80, 60 80))
  </op>
</test>
<test>
  <op name="getboundary" pattern="FFFFFFFFF" arg1="A">
    MULTILINESTRING(
      (60 320, 60 80, 300 80, 60 320), 
      (80 280, 80 100, 260 100, 80 280), 
      (120 160, 140 160, 140 140, 120 160))
  </op>
</test>
<test>
  <op name="symdifference" pattern="FFFFFFFFF" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(100 240, 100 180, 160 180, 160 120, 220 120), 
      LINESTRING(40 360, 40 60), 
      LINESTRING(40 60, 340 60, 40 360), 
      LINESTRING(40 60, 40 20), 
      LINESTRING(120 120, 120 140, 100 140, 100 120, 120 120), 
      LINESTRING(120 120, 140 120), 
      POLYGON(
        (60 320, 300 80, 60 80, 60 320), 
        (80 280, 80 100, 260 100, 80 280)), 
      POLYGON(
        (120 160, 140 160, 140 140, 120 160)))
  </op>
</test>
<test>
  <op name="difference" pattern="FFFFFFFFF" arg1="A" arg2="B">
    MULTIPOLYGON(
      (
        (60 320, 300 80, 60 80, 60 320), 
        (80 280, 80 100, 260 100, 80 280)), 
      (
        (120 160, 140 160, 140 140, 120 160)))
  </op>
</test>
<test>
  <op name="union" pattern="FFFFFFFFF" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(100 240, 100 180, 160 180, 160 120, 220 120), 
      LINESTRING(40 360, 40 60), 
      LINESTRING(40 60, 340 60, 40 360), 
      LINESTRING(40 60, 40 20), 
      LINESTRING(120 120, 120 140, 100 140, 100 120, 120 120), 
      LINESTRING(120 120, 140 120), 
      POLYGON(
        (60 320, 300 80, 60 80, 60 320), 
        (80 280, 80 100, 260 100, 80 280)), 
      POLYGON(
        (120 160, 140 160, 140 140, 120 160)))
  </op>
</test>
<test>
  <op name="intersection" pattern="FFFFFFFFF" arg1="A" arg2="B">
    LINESTRING EMPTY
  </op>
</test>
</case>

<case>
  <desc>mLmA - A and B complex, overlapping and touching #1</desc>
  <a>
    MULTIPOLYGON(
      (
        (60 260, 60 120, 220 120, 220 260, 60 260), 
        (80 240, 80 140, 200 140, 200 240, 80 240)), 
      (
        (100 220, 100 160, 180 160, 180 220, 100 220), 
        (120 200, 120 180, 160 180, 160 200, 120 200)))
  </a>
  <b>
    MULTILINESTRING(
      (40 260, 240 260, 240 240, 40 240, 40 220, 240 220), 
      (120 300, 120 80, 140 80, 140 300, 140 80, 120 80, 120 320))
  </b>
  <test>
    <op name="getboundary" arg1="A">
      MULTILINESTRING(
        (60 260, 60 120, 220 120, 220 260, 60 260), 
        (80 240, 80 140, 200 140, 200 240, 80 240), 
        (100 220, 100 160, 180 160, 180 220, 100 220), 
        (120 200, 120 180, 160 180, 160 200, 120 200))
          </op>
  </test>
  <test>
    <op name="convexhull" arg1="A">
      POLYGON(
        (60 120, 60 260, 220 260, 220 120, 60 120))
          </op>
  </test>
  <test>
    <op name="intersection" arg1="A" arg2="B">
      MULTILINESTRING(
        (220 260, 140 260), 
        (140 260, 120 260), 
        (120 260, 60 260), 
        (200 240, 140 240), 
        (140 240, 120 240), 
        (120 240, 80 240), 
        (180 220, 140 220), 
        (140 220, 120 220), 
        (120 220, 100 220), 
        (120 200, 120 180), 
        (220 240, 200 240), 
        (80 240, 60 240), 
        (60 220, 80 220), 
        (200 220, 220 220), 
        (120 260, 120 240), 
        (120 220, 120 200), 
        (120 180, 120 160), 
        (120 140, 120 120), 
        (140 120, 140 140), 
        (140 160, 140 180), 
        (140 200, 140 220), 
        (140 240, 140 260))
          </op>
  </test>
  <test>
    <op name="union" arg1="A" arg2="B">
      GEOMETRYCOLLECTION(
        LINESTRING(40 260, 60 260), 
        LINESTRING(220 260, 240 260, 240 240, 220 240), 
        LINESTRING(60 240, 40 240, 40 220, 60 220), 
        LINESTRING(80 220, 100 220), 
        LINESTRING(180 220, 200 220), 
        LINESTRING(220 220, 240 220), 
        LINESTRING(120 300, 120 260), 
        LINESTRING(120 240, 120 220), 
        LINESTRING(120 160, 120 140), 
        LINESTRING(120 120, 120 80), 
        LINESTRING(120 80, 140 80), 
        LINESTRING(140 80, 140 120), 
        LINESTRING(140 140, 140 160), 
        LINESTRING(140 180, 140 200), 
        LINESTRING(140 220, 140 240), 
        LINESTRING(140 260, 140 300), 
        LINESTRING(120 300, 120 320), 
        POLYGON(
          (60 240, 60 260, 120 260, 140 260, 220 260, 220 240, 220 220, 220 120, 140 120, 
          120 120, 60 120, 60 220, 60 240), 
          (80 240, 80 220, 80 140, 120 140, 140 140, 200 140, 200 220, 200 240, 140 240, 
          120 240, 80 240)), 
        POLYGON(
          (120 160, 100 160, 100 220, 120 220, 140 220, 180 220, 180 160, 140 160, 120 160), 
          (120 200, 120 180, 140 180, 160 180, 160 200, 140 200, 120 200)))
          </op>
  </test>
  <test>
    <op name="difference" arg1="A" arg2="B">
      MULTIPOLYGON(
        (
          (60 240, 60 260, 120 260, 140 260, 220 260, 220 240, 220 220, 220 120, 140 120, 
          120 120, 60 120, 60 220, 60 240), 
          (80 240, 80 220, 80 140, 120 140, 140 140, 200 140, 200 220, 200 240, 140 240, 
          120 240, 80 240)), 
        (
          (120 160, 100 160, 100 220, 120 220, 140 220, 180 220, 180 160, 140 160, 120 160), 
          (120 200, 120 180, 140 180, 160 180, 160 200, 140 200, 120 200)))
          </op>
  </test>
  <test>
    <op name="symdifference" arg1="A" arg2="B">
      GEOMETRYCOLLECTION(
        LINESTRING(40 260, 60 260), 
        LINESTRING(220 260, 240 260, 240 240, 220 240), 
        LINESTRING(60 240, 40 240, 40 220, 60 220), 
        LINESTRING(80 220, 100 220), 
        LINESTRING(180 220, 200 220), 
        LINESTRING(220 220, 240 220), 
        LINESTRING(120 300, 120 260), 
        LINESTRING(120 240, 120 220), 
        LINESTRING(120 160, 120 140), 
        LINESTRING(120 120, 120 80), 
        LINESTRING(120 80, 140 80), 
        LINESTRING(140 80, 140 120), 
        LINESTRING(140 140, 140 160), 
        LINESTRING(140 180, 140 200), 
        LINESTRING(140 220, 140 240), 
        LINESTRING(140 260, 140 300), 
        LINESTRING(120 300, 120 320), 
        POLYGON(
          (60 240, 60 260, 120 260, 140 260, 220 260, 220 240, 220 220, 220 120, 140 120, 
          120 120, 60 120, 60 220, 60 240), 
          (80 240, 80 220, 80 140, 120 140, 140 140, 200 140, 200 220, 200 240, 140 240, 
          120 240, 80 240)), 
        POLYGON(
          (120 160, 100 160, 100 220, 120 220, 140 220, 180 220, 180 160, 140 160, 120 160), 
          (120 200, 120 180, 140 180, 160 180, 160 200, 140 200, 120 200)))
          </op>
  </test>
</case><case>
  <desc>mLmA - A and B complex, overlapping and touching #2</desc>
  <a>
    MULTIPOLYGON(
      (
        (60 320, 60 120, 280 120, 280 320, 60 320), 
        (120 260, 120 180, 240 180, 240 260, 120 260)), 
      (
        (280 400, 320 400, 320 360, 280 360, 280 400)), 
      (
        (300 240, 300 220, 320 220, 320 240, 300 240)))
  </a>
  <b>
    MULTILINESTRING(
      (80 300, 80 160, 260 160, 260 300, 80 300, 80 140), 
      (220 360, 220 240, 300 240, 300 360))
  </b>
<test>
  <op name="convexhull" pattern="FFFFFFFFF" arg1="A">
    POLYGON(
      (60 120, 60 320, 280 400, 320 400, 320 220, 280 120, 60 120))
  </op>
</test>
<test>
  <op name="getboundary" pattern="FFFFFFFFF" arg1="A">
    MULTILINESTRING(
      (60 320, 60 120, 280 120, 280 320, 60 320), 
      (120 260, 120 180, 240 180, 240 260, 120 260), 
      (280 400, 320 400, 320 360, 280 360, 280 400), 
      (300 240, 300 220, 320 220, 320 240, 300 240))
  </op>
</test>
<test>
  <op name="symdifference" pattern="FFFFFFFFF" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(220 360, 220 320), 
      LINESTRING(220 260, 220 240, 240 240), 
      LINESTRING(280 240, 300 240), 
      LINESTRING(300 240, 300 360), 
      POLYGON(
        (280 240, 280 120, 60 120, 60 320, 220 320, 280 320, 280 240), 
        (120 260, 120 180, 240 180, 240 240, 240 260, 220 260, 120 260)), 
      POLYGON(
        (280 400, 320 400, 320 360, 300 360, 280 360, 280 400)), 
      POLYGON(
        (300 240, 320 240, 320 220, 300 220, 300 240)))
  </op>
</test>
<test>
  <op name="difference" pattern="FFFFFFFFF" arg1="A" arg2="B">
    MULTIPOLYGON(
      (
        (280 240, 280 120, 60 120, 60 320, 220 320, 280 320, 280 240), 
        (120 260, 120 180, 240 180, 240 240, 240 260, 220 260, 120 260)), 
      (
        (280 400, 320 400, 320 360, 300 360, 280 360, 280 400)), 
      (
        (300 240, 320 240, 320 220, 300 220, 300 240)))
  </op>
</test>
<test>
  <op name="union" pattern="FFFFFFFFF" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(220 360, 220 320), 
      LINESTRING(220 260, 220 240, 240 240), 
      LINESTRING(280 240, 300 240), 
      LINESTRING(300 240, 300 360), 
      POLYGON(
        (280 240, 280 120, 60 120, 60 320, 220 320, 280 320, 280 240), 
        (120 260, 120 180, 240 180, 240 240, 240 260, 220 260, 120 260)), 
      POLYGON(
        (280 400, 320 400, 320 360, 300 360, 280 360, 280 400)), 
      POLYGON(
        (300 240, 320 240, 320 220, 300 220, 300 240)))
  </op>
</test>
<test>
  <op name="intersection" pattern="FFFFFFFFF" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      POINT(300 240), 
      POINT(300 360), 
      LINESTRING(80 300, 80 160), 
      LINESTRING(80 160, 260 160, 260 240), 
      LINESTRING(260 240, 260 300, 220 300), 
      LINESTRING(220 300, 80 300), 
      LINESTRING(80 160, 80 140), 
      LINESTRING(220 320, 220 300), 
      LINESTRING(220 300, 220 260), 
      LINESTRING(240 240, 260 240), 
      LINESTRING(260 240, 280 240))
  </op>
</test>
</case>

<case>
  <desc>mLmA - A and B complex, overlapping and touching #3</desc>
  <a>
    MULTIPOLYGON(
      (
        (120 180, 60 80, 180 80, 120 180)), 
      (
        (100 240, 140 240, 120 220, 100 240)))
  </a>
  <b>
    MULTILINESTRING(
      (180 260, 120 180, 60 260, 180 260), 
      (60 300, 60 40), 
      (100 100, 140 100))
  </b>
<test>
  <op name="convexhull" pattern="FFFFFFFFF" arg1="A">
    POLYGON(
      (60 80, 100 240, 140 240, 180 80, 60 80))
  </op>
</test>
<test>
  <op name="getboundary" pattern="FFFFFFFFF" arg1="A">
    MULTILINESTRING(
      (120 180, 60 80, 180 80, 120 180), 
      (100 240, 140 240, 120 220, 100 240))
  </op>
</test>
<test>
  <op name="symdifference" pattern="FFFFFFFFF" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(180 260, 120 180), 
      LINESTRING(120 180, 60 260), 
      LINESTRING(60 260, 180 260), 
      LINESTRING(60 300, 60 260), 
      LINESTRING(60 260, 60 80), 
      LINESTRING(60 80, 60 40), 
      POLYGON(
        (60 80, 120 180, 180 80, 60 80)), 
      POLYGON(
        (100 240, 140 240, 120 220, 100 240)))
  </op>
</test>
<test>
  <op name="difference" pattern="FFFFFFFFF" arg1="A" arg2="B">
    MULTIPOLYGON(
      (
        (60 80, 120 180, 180 80, 60 80)), 
      (
        (100 240, 140 240, 120 220, 100 240)))
  </op>
</test>
<test>
  <op name="union" pattern="FFFFFFFFF" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      LINESTRING(180 260, 120 180), 
      LINESTRING(120 180, 60 260), 
      LINESTRING(60 260, 180 260), 
      LINESTRING(60 300, 60 260), 
      LINESTRING(60 260, 60 80), 
      LINESTRING(60 80, 60 40), 
      POLYGON(
        (60 80, 120 180, 180 80, 60 80)), 
      POLYGON(
        (100 240, 140 240, 120 220, 100 240)))
  </op>
</test>
<test>
  <op name="intersection" pattern="FFFFFFFFF" arg1="A" arg2="B">
    GEOMETRYCOLLECTION(
      POINT(60 80), 
      POINT(120 180), 
      LINESTRING(100 100, 140 100))
  </op>
</test>
</case>

</run>