Rectangle.js

import {
    Tangram
} from "./Tangram";

/**
 * 矩形几何对象
 * @class Zondy.Object.Rectangle
 * @classdesc 矩形几何对象
 * @extends Zondy.Object.Tangram
 * @param {Number} xmin x最小值
 * @param {Number} xmax x最大值
 * @param {Number} ymin y最小值
 * @param {Number} ymax y最大值
 * @param {Object} option 属性键值对,拓展属性
 */
class Rectangle extends Tangram {
    /// <summary>矩形几何对象构造函数</summary>
    /// <param name="m_arguments" type="String">矩形坐标（"xmin,ymin,xmax,ymax"）</param>
    /// <param name="option" type="Object">属性键值对</param>
    constructor(xmin, ymin, xmax, ymax, option) {
        var options = option ? option : {};
        super(options);

        /**
         * @member Zondy.Object.Rectangle.prototype.xmin
         * @type {Number}
         * @description xmin
         */
        this.xmin = xmin;

        /**
         * @member Zondy.Object.Rectangle.prototype.xmax
         * @type {Number}
         * @description xmax
         */
        this.xmax = xmax;

        /**
         * @member Zondy.Object.Rectangle.prototype.ymin
         * @type {Number}
         * @description ymin
         */
        this.ymin = ymin;

        /**
         * @member Zondy.Object.Rectangle.prototype.ymax
         * @type {Number}
         * @description ymax
         */
        this.ymax = ymax;
    }

    /**
     * @function Zondy.Object.Rectangle.prototype.setByOL
     * @description 使用一个由Openlayers定义的矩形来构造本对象
     * @param {ol.extent} openlayersRect 由OpenLayers定义的矩形对象
     */
    setByOL(openlayersRect) {
        if (openlayersRect === undefined || openlayersRect === null) {
            return;
        }
        this.xmin = openlayersRect[0];
        this.ymin = openlayersRect[1];
        this.xmax = openlayersRect[2];
        this.ymax = openlayersRect[3];
    }

    /**
     * @function Zondy.Object.Rectangle.prototype.toString
     * @description 对象转化为字符串
     * @returns {String} 返回一个字符串来表示此矩形
     */
    toString() {
        return "" + this.xmin + ',' + this.ymin + ',' + this.xmax + ',' + this.ymax;
    }

    /**
     * @function Zondy.Object.Rectangle.prototype.getGeometryType
     * @description 获取几何类型名称
     * @returns {String} rect
     */
    getGeometryType() {
        return "rect";
    }

    /**
     * @function Zondy.Object.Rectangle.prototype.convertToBound
     * @description 将本对象转换为一个OpenLayers.Bound对象
     * @returns {ol.extent} 返回一个字符串来表示此矩形
     */
    convertToBound() {
        var bounds = [this.xmin, this.ymin, this.xmax, this.ymax];
        return bounds;
    }

    /**
     * @function Zondy.Object.Rectangle.prototype.intersectsBounds
     * @description 判断是否和另一个矩形相交
     * @param {ol.extent} bounds
     * @param {String} options 判断参数
     * @param {Boolean} [options.inclusive = true] 是否精准计算
     */
    intersectsBounds(bounds, options) {
        if (typeof options === "boolean") {
            options = {
                inclusive: options
            };
        }
        options = options || {};
        if (options.inclusive === null) {
            options.inclusive = true;
        }
        var self = this;
        var intersects = false;
        var mightTouch = (
            self.xmin === bounds.xmax ||
            self.xmax === bounds.xmin ||
            self.ymax === bounds.ymin ||
            self.ymin === bounds.ymax
        );

        // if the two bounds only touch at an edge, and inclusive is false,
        // then the bounds don't *really* intersect.
        if (options.inclusive || !mightTouch) {
            // otherwise, if one of the boundaries even partially contains another,
            // inclusive of the edges, then they do intersect.
            var inBottom = (
                ((bounds.ymin >= self.ymin) && (bounds.ymin <= self.ymax)) ||
                ((self.ymin >= bounds.ymin) && (self.ymin <= bounds.ymax))
            );
            var inTop = (
                ((bounds.ymax >= self.ymin) && (bounds.ymax <= self.ymax)) ||
                ((self.ymax > bounds.ymin) && (self.ymax < bounds.ymax))
            );
            var inLeft = (
                ((bounds.xmin >= self.xmin) && (bounds.xmin <= self.xmax)) ||
                ((self.xmin >= bounds.xmin) && (self.xmin <= bounds.xmax))
            );
            var inRight = (
                ((bounds.xmax >= self.xmin) && (bounds.xmax <= self.xmax)) ||
                ((self.xmax >= bounds.xmin) && (self.xmax <= bounds.xmax))
            );
            intersects = ((inBottom || inTop) && (inLeft || inRight));
        }
        return intersects;
    }
}
export {
    Rectangle
};
Zondy.Object.Rectangle = Rectangle;