1 2-- spherical polygon functions 3 4 5CREATE FUNCTION npoints(spoly) 6 RETURNS INT4 7 AS 'MODULE_PATHNAME', 'spherepoly_npts' 8 LANGUAGE 'c' 9 IMMUTABLE STRICT; 10 11COMMENT ON FUNCTION npoints(spoly) IS 12 'returns number of points of spherical polygon'; 13 14CREATE FUNCTION area(spoly) 15 RETURNS FLOAT8 16 AS 'MODULE_PATHNAME', 'spherepoly_area' 17 LANGUAGE 'c' 18 IMMUTABLE STRICT; 19 20COMMENT ON FUNCTION area(spoly) IS 21 'returns area of spherical polygon'; 22 23 24 25-- **************************** 26-- 27-- spherical polygon operators 28-- 29-- **************************** 30 31 32-- 33-- equal 34-- 35 36CREATE FUNCTION spoly_equal(spoly, spoly) 37 RETURNS BOOL 38 AS 'MODULE_PATHNAME', 'spherepoly_equal' 39 LANGUAGE 'c' 40 IMMUTABLE STRICT; 41 42COMMENT ON FUNCTION spoly_equal(spoly, spoly) IS 43 'returns true, if spherical polygons are equal'; 44 45 46CREATE OPERATOR = ( 47 LEFTARG = spoly, 48 RIGHTARG = spoly, 49 COMMUTATOR = =, 50 NEGATOR = <>, 51 PROCEDURE = spoly_equal, 52 RESTRICT = contsel, 53 JOIN = contjoinsel 54); 55 56COMMENT ON OPERATOR = (spoly, spoly) IS 57 'true, if spherical polygons are equal'; 58 59-- 60-- not equal 61-- 62 63CREATE FUNCTION spoly_not_equal(spoly, spoly) 64 RETURNS BOOL 65 AS 'MODULE_PATHNAME', 'spherepoly_equal_neg' 66 LANGUAGE 'c' 67 IMMUTABLE STRICT; 68 69COMMENT ON FUNCTION spoly_not_equal(spoly, spoly) IS 70 'returns true, if spherical polygons are not equal'; 71 72CREATE OPERATOR <> ( 73 LEFTARG = spoly, 74 RIGHTARG = spoly, 75 COMMUTATOR = <>, 76 NEGATOR = =, 77 PROCEDURE = spoly_not_equal, 78 RESTRICT = contsel, 79 JOIN = contjoinsel 80); 81 82COMMENT ON OPERATOR <> (spoly, spoly) IS 83 'true, if spherical polygons are not equal'; 84 85-- 86-- circumference 87-- 88 89CREATE FUNCTION circum(spoly) 90 RETURNS FLOAT8 91 AS 'MODULE_PATHNAME', 'spherepoly_circ' 92 LANGUAGE 'c' 93 IMMUTABLE STRICT; 94 95COMMENT ON FUNCTION circum(spoly) IS 96 'returns circumference of spherical polygon'; 97 98CREATE OPERATOR @-@ ( 99 RIGHTARG = spoly, 100 PROCEDURE = circum 101); 102 103COMMENT ON OPERATOR @-@ (NONE, spoly) IS 104 'returns circumference of spherical polygon'; 105 106 107-- 108-- polygon contains polygon 109-- 110 111CREATE FUNCTION spoly_contains_polygon(spoly, spoly) 112 RETURNS BOOL 113 AS 'MODULE_PATHNAME', 'spherepoly_cont_poly' 114 LANGUAGE 'c' 115 IMMUTABLE STRICT; 116 117COMMENT ON FUNCTION spoly_contains_polygon(spoly, spoly) IS 118 'true if spherical polygon contains spherical polygon'; 119 120 121-- 122-- polygon is contained by polygon 123-- 124 125CREATE FUNCTION spoly_contains_polygon_com(spoly, spoly) 126 RETURNS BOOL 127 AS 'MODULE_PATHNAME', 'spherepoly_cont_poly_com' 128 LANGUAGE 'c' 129 IMMUTABLE STRICT; 130 131COMMENT ON FUNCTION spoly_contains_polygon_com(spoly, spoly) IS 132 'true if spherical polygon is contained by spherical polygon'; 133 134 135-- 136-- polygon does not contain polygon 137-- 138 139CREATE FUNCTION spoly_contains_polygon_neg(spoly, spoly) 140 RETURNS BOOL 141 AS 'MODULE_PATHNAME', 'spherepoly_cont_poly_neg' 142 LANGUAGE 'c' 143 IMMUTABLE STRICT; 144 145COMMENT ON FUNCTION spoly_contains_polygon_neg(spoly, spoly) IS 146 'true if spherical polygon does not contain spherical polygon'; 147 148 149-- 150-- polygon is not contained by polygon 151-- 152 153CREATE FUNCTION spoly_contains_polygon_com_neg(spoly, spoly) 154 RETURNS BOOL 155 AS 'MODULE_PATHNAME', 'spherepoly_cont_poly_com_neg' 156 LANGUAGE 'c' 157 IMMUTABLE STRICT; 158 159COMMENT ON FUNCTION spoly_contains_polygon_com_neg(spoly, spoly) IS 160 'true if spherical polygon is not contained by spherical polygon'; 161 162 163-- 164-- polygons overlap 165-- 166 167CREATE FUNCTION spoly_overlap_polygon(spoly, spoly) 168 RETURNS BOOL 169 AS 'MODULE_PATHNAME', 'spherepoly_overlap_poly' 170 LANGUAGE 'c' 171 IMMUTABLE STRICT; 172 173COMMENT ON FUNCTION spoly_overlap_polygon(spoly, spoly) IS 174 'true if spherical polygon overlaps spherical polygon'; 175 176 177CREATE OPERATOR && ( 178 LEFTARG = spoly, 179 RIGHTARG = spoly, 180 PROCEDURE = spoly_overlap_polygon, 181 COMMUTATOR = '&&', 182 NEGATOR = '!&&', 183 RESTRICT = contsel, 184 JOIN = contjoinsel 185); 186 187COMMENT ON OPERATOR && (spoly, spoly) IS 188 'true if spherical polygons overlap'; 189 190-- 191-- polygons do not overlap 192-- 193 194CREATE FUNCTION spoly_overlap_polygon_neg(spoly, spoly) 195 RETURNS BOOL 196 AS 'MODULE_PATHNAME', 'spherepoly_overlap_poly_neg' 197 LANGUAGE 'c' 198 IMMUTABLE STRICT; 199 200COMMENT ON FUNCTION spoly_overlap_polygon_neg(spoly, spoly) IS 201 'true if spherical polygon does not overlap spherical polygon'; 202 203 204CREATE OPERATOR !&& ( 205 LEFTARG = spoly, 206 RIGHTARG = spoly, 207 PROCEDURE = spoly_overlap_polygon, 208 COMMUTATOR = '!&&', 209 NEGATOR = '&&', 210 RESTRICT = contsel, 211 JOIN = contjoinsel 212); 213 214COMMENT ON OPERATOR !&& (spoly, spoly) IS 215 'true if spherical polygon does not overlap spherical polygon'; 216 217 218-- 219-- polygon contains point 220-- 221 222CREATE FUNCTION spoly_contains_point(spoly, spoint) 223 RETURNS BOOL 224 AS 'MODULE_PATHNAME', 'spherepoly_cont_point' 225 LANGUAGE 'c' 226 IMMUTABLE STRICT; 227 228COMMENT ON FUNCTION spoly_contains_point(spoly, spoint) IS 229 'true if spherical polygon contains spherical point'; 230 231-- 232-- point is contained by polygon 233-- 234 235CREATE FUNCTION spoly_contains_point_com(spoint, spoly) 236 RETURNS BOOL 237 AS 'MODULE_PATHNAME', 'spherepoly_cont_point_com' 238 LANGUAGE 'c' 239 IMMUTABLE STRICT; 240 241COMMENT ON FUNCTION spoly_contains_point_com(spoint, spoly) IS 242 'true if spherical polygon contains spherical point'; 243 244-- 245-- polygon does not contain point 246-- 247 248CREATE FUNCTION spoly_contains_point_neg(spoly, spoint) 249 RETURNS BOOL 250 AS 'MODULE_PATHNAME', 'spherepoly_cont_point_neg' 251 LANGUAGE 'c' 252 IMMUTABLE STRICT; 253 254COMMENT ON FUNCTION spoly_contains_point_neg(spoly, spoint) IS 255 'true if spherical polygon does not contain spherical point'; 256 257-- 258-- point is not contained by polygon 259-- 260 261CREATE FUNCTION spoly_contains_point_com_neg(spoint, spoly) 262 RETURNS BOOL 263 AS 'MODULE_PATHNAME', 'spherepoly_cont_point_com_neg' 264 LANGUAGE 'c' 265 IMMUTABLE STRICT; 266 267COMMENT ON FUNCTION spoly_contains_point_com_neg(spoint, spoly) IS 268 'true if spherical polygon does not contain spherical point'; 269 270-- 271-- Transformation of polygon 272-- 273 274CREATE FUNCTION strans_poly(spoly, strans) 275 RETURNS spoly 276 AS 'MODULE_PATHNAME', 'spheretrans_poly' 277 LANGUAGE 'c' 278 IMMUTABLE STRICT; 279 280COMMENT ON FUNCTION strans_poly (spoly, strans) IS 281 'returns a transformated spherical polygon'; 282 283CREATE OPERATOR + ( 284 LEFTARG = spoly, 285 RIGHTARG = strans, 286 PROCEDURE = strans_poly 287); 288 289COMMENT ON OPERATOR + (spoly, strans) IS 290 'transforms a spherical polygon'; 291 292CREATE FUNCTION strans_poly_inverse(spoly, strans) 293 RETURNS spoly 294 AS 'MODULE_PATHNAME', 'spheretrans_poly_inverse' 295 LANGUAGE 'c' 296 IMMUTABLE STRICT; 297 298COMMENT ON FUNCTION strans_poly_inverse (spoly, strans) IS 299 'returns a inverse transformated spherical polygon'; 300 301CREATE OPERATOR - ( 302 LEFTARG = spoly, 303 RIGHTARG = strans, 304 PROCEDURE = strans_poly_inverse 305); 306 307COMMENT ON OPERATOR - (spoly, strans) IS 308 'transforms inverse a spherical polygon'; 309 310 311-- 312-- polygon contains circle 313-- 314 315CREATE FUNCTION spoly_contains_circle(spoly, scircle) 316 RETURNS BOOL 317 AS 'MODULE_PATHNAME', 'spherepoly_cont_circle' 318 LANGUAGE 'c' 319 IMMUTABLE STRICT; 320 321COMMENT ON FUNCTION spoly_contains_circle(spoly, scircle) IS 322 'true if spherical polygon contains spherical circle'; 323 324 325-- 326-- circle is contained by polygon 327-- 328 329CREATE FUNCTION spoly_contains_circle_com(scircle, spoly) 330 RETURNS BOOL 331 AS 'MODULE_PATHNAME', 'spherepoly_cont_circle_com' 332 LANGUAGE 'c' 333 IMMUTABLE STRICT; 334 335COMMENT ON FUNCTION spoly_contains_circle_com(scircle, spoly) IS 336 'true if spherical polygon contains spherical circle'; 337 338 339-- 340-- polygon does not contain circle 341-- 342 343CREATE FUNCTION spoly_contains_circle_neg(spoly, scircle) 344 RETURNS BOOL 345 AS 'MODULE_PATHNAME', 'spherepoly_cont_circle_neg' 346 LANGUAGE 'c' 347 IMMUTABLE STRICT; 348 349COMMENT ON FUNCTION spoly_contains_circle_neg(spoly, scircle) IS 350 'true if spherical polygon does not contain spherical circle'; 351 352 353-- 354-- circle is not contained by polygon 355-- 356 357CREATE FUNCTION spoly_contains_circle_com_neg(scircle, spoly) 358 RETURNS BOOL 359 AS 'MODULE_PATHNAME', 'spherepoly_cont_circle_com_neg' 360 LANGUAGE 'c' 361 IMMUTABLE STRICT; 362 363COMMENT ON FUNCTION spoly_contains_circle_com_neg(scircle, spoly) IS 364 'true if spherical polygon does not contain spherical circle'; 365 366 367-- 368-- circle contains polygon 369-- 370 371CREATE FUNCTION scircle_contains_polygon(scircle, spoly) 372 RETURNS BOOL 373 AS 'MODULE_PATHNAME', 'spherecircle_cont_poly' 374 LANGUAGE 'c' 375 IMMUTABLE STRICT; 376 377COMMENT ON FUNCTION scircle_contains_polygon(scircle, spoly) IS 378 'true if spherical circle contains spherical polygon'; 379 380 381-- 382-- polygon is contained by circle 383-- 384 385CREATE FUNCTION scircle_contains_polygon_com(spoly, scircle) 386 RETURNS BOOL 387 AS 'MODULE_PATHNAME', 'spherecircle_cont_poly_com' 388 LANGUAGE 'c' 389 IMMUTABLE STRICT; 390 391COMMENT ON FUNCTION scircle_contains_polygon_com(spoly, scircle) IS 392 'true if spherical circle contains spherical polygon'; 393 394 395-- 396-- circle does not contain polygon 397-- 398 399CREATE FUNCTION scircle_contains_polygon_neg(scircle, spoly) 400 RETURNS BOOL 401 AS 'MODULE_PATHNAME', 'spherecircle_cont_poly_neg' 402 LANGUAGE 'c' 403 IMMUTABLE STRICT; 404 405COMMENT ON FUNCTION scircle_contains_polygon_neg(scircle, spoly) IS 406 'true if spherical circle does not contain spherical polygon'; 407 408 409-- 410-- polygon is not contained by circle 411-- 412 413CREATE FUNCTION scircle_contains_polygon_com_neg(spoly, scircle) 414 RETURNS BOOL 415 AS 'MODULE_PATHNAME', 'spherecircle_cont_poly_com_neg' 416 LANGUAGE 'c' 417 IMMUTABLE STRICT; 418 419COMMENT ON FUNCTION scircle_contains_polygon_com_neg(spoly, scircle) IS 420 'true if spherical circle does not contain spherical polygon'; 421 422 423-- 424-- circle overlaps polygon 425-- 426 427CREATE FUNCTION spoly_overlap_circle(spoly, scircle) 428 RETURNS BOOL 429 AS 'MODULE_PATHNAME', 'spherepoly_overlap_circle' 430 LANGUAGE 'c' 431 IMMUTABLE STRICT; 432 433COMMENT ON FUNCTION spoly_overlap_circle(spoly, scircle) IS 434 'true if spherical circle overlap spherical polygon'; 435 436 437CREATE OPERATOR && ( 438 LEFTARG = spoly, 439 RIGHTARG = scircle, 440 PROCEDURE = spoly_overlap_circle, 441 COMMUTATOR = '&&', 442 NEGATOR = '!&&', 443 RESTRICT = contsel, 444 JOIN = contjoinsel 445); 446 447COMMENT ON OPERATOR && (spoly, scircle) IS 448 'true if spherical circle overlap spherical polygon'; 449 450-- 451-- polygon overlaps circle 452-- 453 454CREATE FUNCTION spoly_overlap_circle_com(scircle, spoly) 455 RETURNS BOOL 456 AS 'MODULE_PATHNAME', 'spherepoly_overlap_circle_com' 457 LANGUAGE 'c' 458 IMMUTABLE STRICT; 459 460COMMENT ON FUNCTION spoly_overlap_circle_com(scircle, spoly) IS 461 'true if spherical circle overlap spherical polygon'; 462 463 464CREATE OPERATOR && ( 465 LEFTARG = scircle, 466 RIGHTARG = spoly, 467 PROCEDURE = spoly_overlap_circle_com, 468 COMMUTATOR = '&&', 469 NEGATOR = '!&&', 470 RESTRICT = contsel, 471 JOIN = contjoinsel 472); 473 474COMMENT ON OPERATOR && (scircle, spoly) IS 475 'true if spherical circle overlap spherical polygon'; 476 477 478-- 479-- circle does not overlap polygon 480-- 481 482CREATE FUNCTION spoly_overlap_circle_neg(spoly, scircle) 483 RETURNS BOOL 484 AS 'MODULE_PATHNAME', 'spherepoly_overlap_circle_neg' 485 LANGUAGE 'c' 486 IMMUTABLE STRICT; 487 488COMMENT ON FUNCTION spoly_overlap_circle_neg(spoly, scircle) IS 489 'true if spherical circle does not overlap spherical polygon'; 490 491 492CREATE OPERATOR !&& ( 493 LEFTARG = spoly, 494 RIGHTARG = scircle, 495 PROCEDURE = spoly_overlap_circle_neg, 496 COMMUTATOR = '!&&', 497 NEGATOR = '&&', 498 RESTRICT = contsel, 499 JOIN = contjoinsel 500); 501 502COMMENT ON OPERATOR !&& (spoly, scircle) IS 503 'true if spherical circle does not overlap spherical polygon'; 504 505-- 506-- polygon does not overlap circle 507-- 508 509CREATE FUNCTION spoly_overlap_circle_com_neg(scircle, spoly) 510 RETURNS BOOL 511 AS 'MODULE_PATHNAME', 'spherepoly_overlap_circle_com_neg' 512 LANGUAGE 'c' 513 IMMUTABLE STRICT; 514 515COMMENT ON FUNCTION spoly_overlap_circle_com_neg(scircle, spoly) IS 516 'true if spherical circle does not overlap spherical polygon'; 517 518 519CREATE OPERATOR !&& ( 520 LEFTARG = scircle, 521 RIGHTARG = spoly, 522 PROCEDURE = spoly_overlap_circle_com_neg, 523 COMMUTATOR = '!&&', 524 NEGATOR = '&&', 525 RESTRICT = contsel, 526 JOIN = contjoinsel 527); 528 529COMMENT ON OPERATOR !&& (scircle, spoly) IS 530 'true if spherical circle does not overlap spherical polygon'; 531 532 533-- 534-- polygon contains line 535-- 536 537CREATE FUNCTION spoly_contains_line(spoly, sline) 538 RETURNS BOOL 539 AS 'MODULE_PATHNAME', 'spherepoly_cont_line' 540 LANGUAGE 'c' 541 IMMUTABLE STRICT; 542 543COMMENT ON FUNCTION spoly_contains_line(spoly, sline) IS 544 'true if spherical polygon contains spherical line'; 545 546-- 547-- line is contained by polygon 548-- 549 550CREATE FUNCTION spoly_contains_line_com(sline, spoly) 551 RETURNS BOOL 552 AS 'MODULE_PATHNAME', 'spherepoly_cont_line_com' 553 LANGUAGE 'c' 554 IMMUTABLE STRICT; 555 556COMMENT ON FUNCTION spoly_contains_line_com(sline, spoly) IS 557 'true if spherical polygon contains spherical line'; 558 559-- 560-- polygon does not contain line 561-- 562 563CREATE FUNCTION spoly_contains_line_neg(spoly, sline) 564 RETURNS BOOL 565 AS 'MODULE_PATHNAME', 'spherepoly_cont_line_neg' 566 LANGUAGE 'c' 567 IMMUTABLE STRICT; 568 569COMMENT ON FUNCTION spoly_contains_line_neg(spoly, sline) IS 570 'true if spherical polygon does not contain spherical line'; 571 572-- 573-- line is not contained by polygon 574-- 575 576CREATE FUNCTION spoly_contains_line_com_neg(sline, spoly) 577 RETURNS BOOL 578 AS 'MODULE_PATHNAME', 'spherepoly_cont_line_com_neg' 579 LANGUAGE 'c' 580 IMMUTABLE STRICT; 581 582COMMENT ON FUNCTION spoly_contains_line_com_neg(sline, spoly) IS 583 'true if spherical polygon does not contain spherical line'; 584 585-- 586-- line overlaps polygon 587-- 588 589CREATE FUNCTION spoly_overlap_line(spoly, sline) 590 RETURNS BOOL 591 AS 'MODULE_PATHNAME', 'spherepoly_overlap_line' 592 LANGUAGE 'c' 593 IMMUTABLE STRICT; 594 595COMMENT ON FUNCTION spoly_overlap_line(spoly, sline) IS 596 'true if spherical line overlap spherical polygon'; 597 598 599CREATE OPERATOR && ( 600 LEFTARG = spoly, 601 RIGHTARG = sline, 602 PROCEDURE = spoly_overlap_line, 603 COMMUTATOR = '&&', 604 NEGATOR = '!&&', 605 RESTRICT = contsel, 606 JOIN = contjoinsel 607); 608 609COMMENT ON OPERATOR && (spoly, sline) IS 610 'true if spherical line overlap spherical polygon'; 611 612-- 613-- polygon overlaps line 614-- 615 616CREATE FUNCTION spoly_overlap_line_com(sline, spoly) 617 RETURNS BOOL 618 AS 'MODULE_PATHNAME', 'spherepoly_overlap_line_com' 619 LANGUAGE 'c' 620 IMMUTABLE STRICT; 621 622COMMENT ON FUNCTION spoly_overlap_line_com(sline, spoly) IS 623 'true if spherical line overlap spherical polygon'; 624 625 626CREATE OPERATOR && ( 627 LEFTARG = sline, 628 RIGHTARG = spoly, 629 PROCEDURE = spoly_overlap_line_com, 630 COMMUTATOR = '&&', 631 NEGATOR = '!&&', 632 RESTRICT = contsel, 633 JOIN = contjoinsel 634); 635 636COMMENT ON OPERATOR && (sline, spoly) IS 637 'true if spherical line overlap spherical polygon'; 638 639 640-- 641-- line does not overlap polygon 642-- 643 644CREATE FUNCTION spoly_overlap_line_neg(spoly, sline) 645 RETURNS BOOL 646 AS 'MODULE_PATHNAME', 'spherepoly_overlap_line_neg' 647 LANGUAGE 'c' 648 IMMUTABLE STRICT; 649 650COMMENT ON FUNCTION spoly_overlap_line_neg(spoly, sline) IS 651 'true if spherical line does not overlap spherical polygon'; 652 653 654CREATE OPERATOR !&& ( 655 LEFTARG = spoly, 656 RIGHTARG = sline, 657 PROCEDURE = spoly_overlap_line_neg, 658 COMMUTATOR = '!&&', 659 NEGATOR = '&&', 660 RESTRICT = contsel, 661 JOIN = contjoinsel 662); 663 664COMMENT ON OPERATOR !&& (spoly, sline) IS 665 'true if spherical line does not overlap spherical polygon'; 666 667-- 668-- polygon does not overlap line 669-- 670 671CREATE FUNCTION spoly_overlap_line_com_neg(sline, spoly) 672 RETURNS BOOL 673 AS 'MODULE_PATHNAME', 'spherepoly_overlap_line_com_neg' 674 LANGUAGE 'c' 675 IMMUTABLE STRICT; 676 677COMMENT ON FUNCTION spoly_overlap_line_com_neg(sline, spoly) IS 678 'true if spherical line does not overlap spherical polygon'; 679 680 681CREATE OPERATOR !&& ( 682 LEFTARG = sline, 683 RIGHTARG = spoly, 684 PROCEDURE = spoly_overlap_line_com_neg, 685 COMMUTATOR = '!&&', 686 NEGATOR = '&&', 687 RESTRICT = contsel, 688 JOIN = contjoinsel 689); 690 691COMMENT ON OPERATOR !&& (sline, spoly) IS 692 'true if spherical line does not overlap spherical polygon'; 693 694 695 696-- 697-- polygon contains ellipse 698-- 699 700CREATE FUNCTION spoly_contains_ellipse(spoly, sellipse) 701 RETURNS BOOL 702 AS 'MODULE_PATHNAME', 'spherepoly_cont_ellipse' 703 LANGUAGE 'c' 704 IMMUTABLE STRICT; 705 706COMMENT ON FUNCTION spoly_contains_ellipse(spoly, sellipse) IS 707 'true if spherical polygon contains spherical ellipse'; 708 709 710-- 711-- ellipse is contained by polygon 712-- 713 714CREATE FUNCTION spoly_contains_ellipse_com(sellipse, spoly) 715 RETURNS BOOL 716 AS 'MODULE_PATHNAME', 'spherepoly_cont_ellipse_com' 717 LANGUAGE 'c' 718 IMMUTABLE STRICT; 719 720COMMENT ON FUNCTION spoly_contains_ellipse_com(sellipse, spoly) IS 721 'true if spherical polygon contains spherical ellipse'; 722 723 724-- 725-- polygon does not contain ellipse 726-- 727 728CREATE FUNCTION spoly_contains_ellipse_neg(spoly, sellipse) 729 RETURNS BOOL 730 AS 'MODULE_PATHNAME', 'spherepoly_cont_ellipse_neg' 731 LANGUAGE 'c' 732 IMMUTABLE STRICT; 733 734COMMENT ON FUNCTION spoly_contains_ellipse_neg(spoly, sellipse) IS 735 'true if spherical polygon does not contain spherical ellipse'; 736 737 738-- 739-- ellipse is not contained by polygon 740-- 741 742CREATE FUNCTION spoly_contains_ellipse_com_neg(sellipse, spoly) 743 RETURNS BOOL 744 AS 'MODULE_PATHNAME', 'spherepoly_cont_ellipse_com_neg' 745 LANGUAGE 'c' 746 IMMUTABLE STRICT; 747 748COMMENT ON FUNCTION spoly_contains_ellipse_com_neg(sellipse, spoly) IS 749 'true if spherical polygon does not contain spherical ellipse'; 750 751 752-- 753-- ellipse contains polygon 754-- 755 756CREATE FUNCTION sellipse_contains_polygon(sellipse, spoly) 757 RETURNS BOOL 758 AS 'MODULE_PATHNAME', 'sphereellipse_cont_poly' 759 LANGUAGE 'c' 760 IMMUTABLE STRICT; 761 762COMMENT ON FUNCTION sellipse_contains_polygon(sellipse, spoly) IS 763 'true if spherical ellipse contains spherical polygon'; 764 765 766-- 767-- polygon is contained by ellipse 768-- 769 770CREATE FUNCTION sellipse_contains_polygon_com(spoly, sellipse) 771 RETURNS BOOL 772 AS 'MODULE_PATHNAME', 'sphereellipse_cont_poly_com' 773 LANGUAGE 'c' 774 IMMUTABLE STRICT; 775 776COMMENT ON FUNCTION sellipse_contains_polygon_com(spoly, sellipse) IS 777 'true if spherical ellipse contains spherical polygon'; 778 779 780-- 781-- ellipse does not contain polygon 782-- 783 784CREATE FUNCTION sellipse_contains_polygon_neg(sellipse, spoly) 785 RETURNS BOOL 786 AS 'MODULE_PATHNAME', 'sphereellipse_cont_poly_neg' 787 LANGUAGE 'c' 788 IMMUTABLE STRICT; 789 790COMMENT ON FUNCTION sellipse_contains_polygon_neg(sellipse, spoly) IS 791 'true if spherical ellipse does not contain spherical polygon'; 792 793 794-- 795-- polygon is not contained by ellipse 796-- 797 798CREATE FUNCTION sellipse_contains_polygon_com_neg(spoly, sellipse) 799 RETURNS BOOL 800 AS 'MODULE_PATHNAME', 'sphereellipse_cont_poly_com_neg' 801 LANGUAGE 'c' 802 IMMUTABLE STRICT; 803 804COMMENT ON FUNCTION sellipse_contains_polygon_com_neg(spoly, sellipse) IS 805 'true if spherical ellipse does not contain spherical polygon'; 806 807 808-- 809-- ellipse overlaps polygon 810-- 811 812CREATE FUNCTION spoly_overlap_ellipse(spoly, sellipse) 813 RETURNS BOOL 814 AS 'MODULE_PATHNAME', 'spherepoly_overlap_ellipse' 815 LANGUAGE 'c' 816 IMMUTABLE STRICT; 817 818COMMENT ON FUNCTION spoly_overlap_ellipse(spoly, sellipse) IS 819 'true if spherical ellipse overlap spherical polygon'; 820 821 822CREATE OPERATOR && ( 823 LEFTARG = spoly, 824 RIGHTARG = sellipse, 825 PROCEDURE = spoly_overlap_ellipse, 826 COMMUTATOR = '&&', 827 NEGATOR = '!&&', 828 RESTRICT = contsel, 829 JOIN = contjoinsel 830); 831 832COMMENT ON OPERATOR && (spoly, sellipse) IS 833 'true if spherical ellipse overlap spherical polygon'; 834 835-- 836-- polygon overlaps ellipse 837-- 838 839CREATE FUNCTION spoly_overlap_ellipse_com(sellipse, spoly) 840 RETURNS BOOL 841 AS 'MODULE_PATHNAME', 'spherepoly_overlap_ellipse_com' 842 LANGUAGE 'c' 843 IMMUTABLE STRICT; 844 845COMMENT ON FUNCTION spoly_overlap_ellipse_com(sellipse, spoly) IS 846 'true if spherical ellipse overlap spherical polygon'; 847 848 849CREATE OPERATOR && ( 850 LEFTARG = sellipse, 851 RIGHTARG = spoly, 852 PROCEDURE = spoly_overlap_ellipse_com, 853 COMMUTATOR = '&&', 854 NEGATOR = '!&&', 855 RESTRICT = contsel, 856 JOIN = contjoinsel 857); 858 859COMMENT ON OPERATOR && (sellipse, spoly) IS 860 'true if spherical ellipse overlap spherical polygon'; 861 862 863-- 864-- ellipse does not overlap polygon 865-- 866 867CREATE FUNCTION spoly_overlap_ellipse_neg(spoly, sellipse) 868 RETURNS BOOL 869 AS 'MODULE_PATHNAME', 'spherepoly_overlap_ellipse_neg' 870 LANGUAGE 'c' 871 IMMUTABLE STRICT; 872 873COMMENT ON FUNCTION spoly_overlap_ellipse_neg(spoly, sellipse) IS 874 'true if spherical ellipse does not overlap spherical polygon'; 875 876 877CREATE OPERATOR !&& ( 878 LEFTARG = spoly, 879 RIGHTARG = sellipse, 880 PROCEDURE = spoly_overlap_ellipse_neg, 881 COMMUTATOR = '!&&', 882 NEGATOR = '&&', 883 RESTRICT = contsel, 884 JOIN = contjoinsel 885); 886 887COMMENT ON OPERATOR !&& (spoly, sellipse) IS 888 'true if spherical ellipse does not overlap spherical polygon'; 889 890-- 891-- polygon does not overlap ellipse 892-- 893 894CREATE FUNCTION spoly_overlap_ellipse_com_neg(sellipse, spoly) 895 RETURNS BOOL 896 AS 'MODULE_PATHNAME', 'spherepoly_overlap_ellipse_com_neg' 897 LANGUAGE 'c' 898 IMMUTABLE STRICT; 899 900COMMENT ON FUNCTION spoly_overlap_ellipse_com_neg(sellipse, spoly) IS 901 'true if spherical ellipse does not overlap spherical polygon'; 902 903 904CREATE OPERATOR !&& ( 905 LEFTARG = sellipse, 906 RIGHTARG = spoly, 907 PROCEDURE = spoly_overlap_ellipse_com_neg, 908 COMMUTATOR = '!&&', 909 NEGATOR = '&&', 910 RESTRICT = contsel, 911 JOIN = contjoinsel 912); 913 914COMMENT ON OPERATOR !&& (sellipse, spoly) IS 915 'true if spherical ellipse does not overlap spherical polygon'; 916 917 918-- 919-- Aggregate functions to add points to polygon 920-- 921 922CREATE FUNCTION spoly_add_point_aggr (spoly, spoint) 923 RETURNS spoly 924 AS 'MODULE_PATHNAME', 'spherepoly_add_point' 925 LANGUAGE 'c' 926 IMMUTABLE; 927 928COMMENT ON FUNCTION spoly_add_point_aggr (spoly, spoint) IS 929 'adds a spherical point to spherical polygon. Do not use it standalone!'; 930 931CREATE FUNCTION spoly_add_points_fin_aggr (spoly) 932 RETURNS spoly 933 AS 'MODULE_PATHNAME', 'spherepoly_add_points_finalize' 934 LANGUAGE 'c' 935 IMMUTABLE STRICT ; 936 937COMMENT ON FUNCTION spoly_add_points_fin_aggr (spoly) IS 938 'Finalize spherical point adding to spherical polygon. Do not use it standalone!'; 939 940CREATE AGGREGATE spoly ( 941 sfunc = spoly_add_point_aggr, 942 basetype = spoint, 943 stype = spoly, 944 finalfunc = spoly_add_points_fin_aggr 945); 946