jsxgraph 1.4.5 → 1.4.6

package/src/base/board.js

@@ -334,7 +334,7 @@ define([
         this.numObjects = 0;
 
         /**
-         * An associative array to store the objects of the board by name. the name of the object is the key and value is a reference to the object.
+         * An associative array / dictionary to store the objects of the board by name. The name of the object is the key and value is a reference to the object.
          * @type Object
          */
         this.elementsByName = {};
@@ -819,7 +819,7 @@ define([
                 // In ownerDoc we need the "real" document object.
                 // The first version is used in the case of shadowDom,
                 // the second case in the "normal" case.
-                ownerDoc = this.document.ownerDocument || this.document, 
+                ownerDoc = this.document.ownerDocument || this.document,
                 docElement = ownerDoc.documentElement || this.document.body.parentNode,
                 docBody = ownerDoc.body,
                 container = this.containerObj,
@@ -5345,7 +5345,7 @@ define([
                 return s;
             }
 
-            // it's a string, most likely an id or a name.
+            // It's a string, most likely an id or a name.
             if (Type.isString(s) && s !== '') {
                 // Search by ID
                 if (Type.exists(this.objects[s])) {
@@ -5357,7 +5357,8 @@ define([
                 } else if (Type.exists(this.groups[s])) {
                     s = this.groups[s];
                 }
-            // it's a function or an object, but not an element
+
+            // It's a function or an object, but not an element
             } else if (!onlyByIdOrName &&
                 (Type.isFunction(s) ||
                  (Type.isObject(s) && !Type.isFunction(s.setAttribute))
@@ -5370,7 +5371,8 @@ define([
                     olist[flist[i].id] = flist[i];
                 }
                 s = new Composition(olist);
-            // it's an element which has been deleted (and still hangs around, e.g. in an attractor list
+
+            // It's an element which has been deleted (and still hangs around, e.g. in an attractor list
             } else if (Type.isObject(s) && Type.exists(s.id) && !Type.exists(this.objects[s.id])) {
                 s = null;
             }
@@ -6006,7 +6008,7 @@ define([
          */
         toFullscreen: function (id) {
             var wrap_id, wrap_node, inner_node,
-                doc = this.document;
+                doc = this.document, fullscreenElement;
 
             id = id || this.container;
             this._fullscreen_inner_id = id;
@@ -6026,7 +6028,7 @@ define([
 
             // Get the real width and height of the JSXGraph div
             // and determine the scaling and vertical shift amount
-            this._fullscreen_res = Env._getScaleFactors(inner_node);
+            // this._fullscreen_res = Env._getScaleFactors(inner_node);
 
             // Trigger fullscreen mode
             wrap_node.requestFullscreen = wrap_node.requestFullscreen ||
@@ -6034,14 +6036,24 @@ define([
                 wrap_node.mozRequestFullScreen ||
                 wrap_node.msRequestFullscreen;
 
-            if (doc.fullscreenElement === null) {
+            if (doc.fullscreenElement !== undefined) {
+                fullscreenElement = doc.fullscreenElement;
+            } else if (doc.webkitFullscreenElement !== undefined) {
+                fullscreenElement = doc.webkitFullscreenElement;
+            } else {
+                fullscreenElement = doc.msFullscreenElement;
+            }
+            if (fullscreenElement === null) {
                 // Start fullscreen mode
                 if (wrap_node.requestFullscreen) {
                     wrap_node.requestFullscreen();
                 }
             } else {
-                // Leave fullscreen mode (e.g. when clicking on the icon)
-                document.exitFullscreen();
+                if (Type.exists(document.exitFullscreen)) {
+                    document.exitFullscreen();
+                } else if (Type.exists(document.webkitExitFullscreen)) {
+                    document.webkitExitFullscreen();
+                }
             }
 
             return this;
@@ -6055,7 +6067,7 @@ define([
          * @param  {Object} evt fullscreen event object (unused)
          */
         fullscreenListener: function (evt) {
-            var res, inner_id, inner_node,
+            var inner_id, inner_node, fullscreenElement, // res,
                 doc = this.document;
 
             inner_id = this._fullscreen_inner_id;
@@ -6063,20 +6075,23 @@ define([
                 return;
             }
 
-            doc.fullscreenElement = doc.fullscreenElement ||
-                    doc.webkitFullscreenElement ||
-                    doc.mozFullscreenElement ||
-                    doc.msFullscreenElement;
+            if (doc.fullscreenElement !== undefined) {
+                fullscreenElement = doc.fullscreenElement;
+            } else if (doc.webkitFullscreenElement !== undefined) {
+                fullscreenElement = doc.webkitFullscreenElement;
+            } else {
+                fullscreenElement = doc.msFullscreenElement;
+            }
 
             inner_node = doc.getElementById(inner_id);
             // If full screen mode is started we have to remove CSS margin around the JSXGraph div.
             // Otherwise, the positioning of the fullscreen div will be false.
             // When leaving the fullscreen mode, the margin is put back in.
-            if (doc.fullscreenElement) {
+            if (fullscreenElement) {
                 // Just entered fullscreen mode
 
                 // Get the data computed in board.toFullscreen()
-                res = this._fullscreen_res;
+                // res = this._fullscreen_res;
 
                 // Store the scaling data.
                 // It is used in AbstractRenderer.updateText to restore the scaling matrix
@@ -6084,25 +6099,26 @@ define([
                 // Further, the CSS margin has to be removed when in fullscreen mode,
                 // and must be restored later.
                 inner_node._cssFullscreenStore = {
-                    id: doc.fullscreenElement.id,
+                    id: fullscreenElement.id,
                     isFullscreen: true,
                     margin: inner_node.style.margin,
-                    width: inner_node.style.width,
-                    scale: res.scale,
-                    vshift: res.vshift
+                    // width: inner_node.style.width
+                    // scale: res.scale,
+                    // vshift: res.vshift
                 };
 
                 inner_node.style.margin = '';
-                inner_node.style.width = res.width + 'px';
+                // inner_node.style.width = res.width + 'px';
 
                 // Do the shifting and scaling via CSS pseudo rules
                 // We do this after fullscreen mode has been established to get the correct size
                 // of the JSXGraph div.
-                Env.scaleJSXGraphDiv(doc.fullscreenElement.id, inner_id, res.scale, res.vshift, doc);
+                // Env.scaleJSXGraphDiv(fullscreenElement.id, inner_id, res.scale, res.vshift, res.ratio, doc);
+                Env.scaleJSXGraphDiv(fullscreenElement.id, inner_id, doc);
 
-                // Clear this.document.fullscreenElement, because Safari doesn't to it and
+                // Clear this.doc.fullscreenElement, because Safari doesn't to it and
                 // when leaving full screen mode it is still set.
-                doc.fullscreenElement = null;
+                fullscreenElement = null;
 
             } else if (Type.exists(inner_node._cssFullscreenStore)) {
                 // Just left the fullscreen mode
@@ -6116,7 +6132,7 @@ define([
 
                 inner_node._cssFullscreenStore.isFullscreen = false;
                 inner_node.style.margin = inner_node._cssFullscreenStore.margin;
-                inner_node.style.width = inner_node._cssFullscreenStore.width;
+                // inner_node.style.width = inner_node._cssFullscreenStore.width;
             }
 
             this.updateCSSTransforms();

package/src/base/constants.js

@@ -42,7 +42,7 @@ define(['jxg'], function (JXG) {
 
     var major = 1,
         minor = 4,
-        patch = 5,
+        patch = 6,
         add = '', //'dev'
         version = major + '.' + minor + '.' + patch + (add ? '-' + add : ''),
         constants;
@@ -111,7 +111,13 @@ define(['jxg'], function (JXG) {
         OBJECT_TYPE_BUTTON: 29,
         OBJECT_TYPE_TRANSFORMATION: 30,
         OBJECT_TYPE_FOREIGNOBJECT: 31,
+
         OBJECT_TYPE_VIEW3D: 32,
+        OBJECT_TYPE_POINT3D: 33,
+        OBJECT_TYPE_LINE3D: 34,
+        OBJECT_TYPE_PLANE3D: 35,
+        OBJECT_TYPE_CURVE3D: 36,
+        OBJECT_TYPE_SURFACE3D: 37,
 
         // IMPORTANT:
         // ----------
@@ -127,6 +133,7 @@ define(['jxg'], function (JXG) {
         OBJECT_CLASS_AREA: 5,
         OBJECT_CLASS_OTHER: 6,
         OBJECT_CLASS_TEXT: 7,
+        OBJECT_CLASS_3D: 8,
 
         // SketchReader constants
         GENTYPE_ABC: 1, // unused

package/src/base/curve.js

@@ -235,7 +235,7 @@ define([
          */
         hasPoint: function (x, y, start) {
             var t, checkPoint, len, invMat, c,
-                i, tX, tY,
+                i, tX, tY, isIn,
                 res = [],
                 points, qdt,
                 steps = Type.evaluate(this.visProp.numberpointslow),
@@ -255,10 +255,20 @@ define([
                 // 'inherit'
                 prec = this.board.options.precision.hasPoint;
             }
+
+            // From now on, x,y are usrCoords
             checkPoint = new Coords(Const.COORDS_BY_SCREEN, [x, y], this.board, false);
             x = checkPoint.usrCoords[1];
             y = checkPoint.usrCoords[2];
 
+            // Handle inner points of the curve
+            if (this.bezierDegree === 1 && Type.evaluate(this.visProp.hasinnerpoints)) {
+                isIn = Geometry.windingNumber([1, x, y], this.points, true);
+                if (isIn !== 0) {
+                    return true;
+                }
+            }
+
             // We use usrCoords. Only in the final distance calculation
             // screen coords are used
             prec += Type.evaluate(this.visProp.strokewidth) * 0.5;
@@ -276,11 +286,11 @@ define([
 
             ev_ct = Type.evaluate(this.visProp.curvetype);
             if (ev_ct === 'parameter' || ev_ct === 'polar') {
+
+                // Transform the mouse/touch coordinates
+                // back to the original position of the curve.
+                // This is needed, because we work with the function terms, not the points.
                 if (this.transformations.length > 0) {
-                    /**
-                     * Transform the mouse/touch coordinates
-                     * back to the original position of the curve.
-                     */
                     this.updateTransformMatrix();
                     invMat = Mat.inverse(this.transformMat);
                     c = Mat.matVecMult(invMat, [1, x, y]);
@@ -304,6 +314,9 @@ define([
             } else if (ev_ct === 'plot' ||
                 ev_ct === 'functiongraph') {
 
+                // Here, we can ignore transformations of the curve,
+                // since we are working directly with the points.
+
                 if (!Type.exists(start) || start < 0) {
                     start = 0;
                 }
@@ -1209,8 +1222,37 @@ define([
                 }
             }
             return [isTransformed, curve_org];
+        },
+
+        pnpoly: function(x_in, y_in, coord_type) {
+            var i, j, len,
+                x, y, crds,
+                v = this.points,
+                isIn = false;
+
+            if (coord_type === Const.COORDS_BY_USER) {
+                crds = new Coords(Const.COORDS_BY_USER, [x_in, y_in], this.board);
+                x = crds.scrCoords[1];
+                y = crds.scrCoords[2];
+            } else {
+                x = x_in;
+                y = y_in;
+            }
+
+            len = this.points.length;
+            for (i = 0, j = len - 2; i < len - 1; j = i++) {
+                if (((v[i].scrCoords[2] > y) !== (v[j].scrCoords[2] > y)) &&
+                    (x < (v[j].scrCoords[1] - v[i].scrCoords[1]) *
+                    (y - v[i].scrCoords[2]) / (v[j].scrCoords[2] - v[i].scrCoords[2]) + v[i].scrCoords[1])
+                   ) {
+                    isIn = !isIn;
+                }
+            }
+
+            return isIn;
         }
 
+
     });
 
     /**
@@ -1378,13 +1420,13 @@ define([
             attr = Type.copyAttributes(attributes, board.options, 'curve');
 
         obj = board.select(parents[0], true);
-        if (Type.isObject(obj) &&
+        if (Type.isTransformationOrArray(parents[1]) &&
+            Type.isObject(obj) &&
             (obj.type === Const.OBJECT_TYPE_CURVE ||
                 obj.type === Const.OBJECT_TYPE_ANGLE ||
                 obj.type === Const.OBJECT_TYPE_ARC ||
                 obj.type === Const.OBJECT_TYPE_CONIC ||
-                obj.type === Const.OBJECT_TYPE_SECTOR) &&
-            Type.isTransformationOrArray(parents[1])) {
+                obj.type === Const.OBJECT_TYPE_SECTOR) ) {
 
             if (obj.type === Const.OBJECT_TYPE_SECTOR) {
                 attr = Type.copyAttributes(attributes, board.options, 'sector');
@@ -2326,7 +2368,7 @@ define([
         /**
          * @ignore
          */
-         c.updateDataArray = function () {
+        c.updateDataArray = function () {
             var i, j = 0,
                 len = this.xterm.length;
 

package/src/base/polygon.js

@@ -80,6 +80,14 @@ define([
         this.vertices = [];
         for (i = 0; i < vertices.length; i++) {
             this.vertices[i] = this.board.select(vertices[i]);
+
+            // The _is_new flag is replaced by _is_new_pol.
+            // Otherwise, the polygon would disappear if the last border element
+            // is removed (and the point has been provided by coordinates)
+            if (this.vertices[i]._is_new) {
+                delete this.vertices[i]._is_new;
+                this.vertices[i]._is_new_pol = true;
+            }
         }
 
         // Close the polygon
@@ -127,9 +135,9 @@ define([
         // - add  points (supplied as coordinate arrays by the user and created by Type.providePoints) as children to the polygon
         for (i = 0; i < this.vertices.length - 1; i++) {
             p = this.board.select(this.vertices[i]);
-            if (Type.exists(p._is_new)) {
+            if (Type.exists(p._is_new_pol)) {
                 this.addChild(p);
-                delete p._is_new;
+                delete p._is_new_pol;
             } else {
                 p.addChild(this);
             }
@@ -165,10 +173,7 @@ define([
     JXG.extend(JXG.Polygon.prototype, /** @lends JXG.Polygon.prototype */ {
 
         /**
-         * Decides if a point (x,y) is inside of the polygon.
-         * Implements W. Randolf Franklin's pnpoly method.
-         *
-         * See <a href="https://wrf.ecse.rpi.edu/Research/Short_Notes/pnpoly.html">https://wrf.ecse.rpi.edu/Research/Short_Notes/pnpoly.html</a>.
+         * Wrapper for JXG.Math.Geometry.pnpoly.
          *
          * @param {Number} x_in x-coordinate (screen or user coordinates)
          * @param {Number} y_in y-coordinate (screen or user coordinates)
@@ -176,7 +181,9 @@ define([
          *   Possible values are <b>JXG.COORDS_BY_USER</b> and <b>JXG.COORDS_BY_SCREEN</b>.
          *   Default value is JXG.COORDS_BY_SCREEN
          *
-         * @returns {Boolean} if (x,y) is inside of the polygon.
+         * @returns {Boolean} if (x_in, y_in) is inside of the polygon.
+         * @see JXG.Math.Geometry#pnpoly
+         *
          * @example
          * var pol = board.create('polygon', [[-1,2], [2,2], [-1,4]]);
          * var p = board.create('point', [4, 3]);
@@ -202,31 +209,7 @@ define([
          *
          */
         pnpoly: function(x_in, y_in, coord_type) {
-            var i, j, len,
-                x, y, crds,
-                v = this.vertices,
-                isIn = false;
-
-            if (coord_type === Const.COORDS_BY_USER) {
-                crds = new Coords(Const.COORDS_BY_USER, [x_in, y_in], this.board);
-                x = crds.scrCoords[1];
-                y = crds.scrCoords[2];
-            } else {
-                x = x_in;
-                y = y_in;
-            }
-
-            len = this.vertices.length;
-            for (i = 0, j = len - 2; i < len - 1; j = i++) {
-                if (((v[i].coords.scrCoords[2] > y) !== (v[j].coords.scrCoords[2] > y)) &&
-                    (x < (v[j].coords.scrCoords[1] - v[i].coords.scrCoords[1]) *
-                    (y - v[i].coords.scrCoords[2]) / (v[j].coords.scrCoords[2] - v[i].coords.scrCoords[2]) + v[i].coords.scrCoords[1])
-                   ) {
-                    isIn = !isIn;
-                }
-            }
-
-            return isIn;
+            return Geometry.pnpoly(x_in, y_in, this.vertices, coord_type);
         },
 
         /**
@@ -590,9 +573,14 @@ define([
          *
          */
         addPoints: function (p) {
-            var args = Array.prototype.slice.call(arguments);
+            var idx, args = Array.prototype.slice.call(arguments);
 
-            return this.insertPoints.apply(this, [this.vertices.length - 2].concat(args));
+            if (this.elType === 'polygonalchain') {
+                idx = this.vertices.length - 1;
+            } else {
+                idx = this.vertices.length - 2;
+            }
+            return this.insertPoints.apply(this, [idx].concat(args));
         },
 
         /**
@@ -630,38 +618,65 @@ define([
          *
          */
         insertPoints: function (idx, p) {
-            var i, le;
+            var i, le, last, start, q;
 
             if (arguments.length === 0) {
                 return this;
             }
 
+            last = this.vertices.length - 1;
+            if (this.elType === 'polygon') {
+                last--;
+            }
 
-            if (idx < -1 || idx > this.vertices.length - 2) {
+            // Wrong insertion index, get out of here
+            if (idx < -1 || idx > last) {
                 return this;
             }
 
             le = arguments.length - 1;
             for (i = 1; i < le + 1; i++) {
-                this.vertices.splice(idx + i, 0,
-                    Type.providePoints(this.board, [arguments[i]], {}, 'polygon', ['vertices'])[0]
-                );
-            }
-            if (idx === -1) {
-                this.vertices[this.vertices.length - 1] = this.vertices[0];
+                q = Type.providePoints(this.board, [arguments[i]], {}, 'polygon', ['vertices'])[0];
+                if (q._is_new) {
+                    // Add the point as child of the polygon, but not of the borders.
+                    this.addChild(q);
+                    delete q._is_new;
+                }
+                this.vertices.splice(idx + i, 0, q);
             }
+
             if (this.withLines) {
-                if (idx < 0) {
-                    this.borders[this.borders.length - 1].point2 = this.vertices[this.vertices.length - 1];
+                start = idx + 1;
+                if (this.elType === 'polygon') {
+                    if (idx < 0) {
+                        // Add point(s) in the front
+                        this.vertices[this.vertices.length - 1] = this.vertices[0];
+                        this.borders[this.borders.length - 1].point2 = this.vertices[this.vertices.length - 1];
+                    } else {
+                        // Insert point(s) (middle or end)
+                        this.borders[idx].point2 = this.vertices[start];
+                    }
                 } else {
-                    this.borders[idx].point2 = this.vertices[idx + 1];
+                    // Add point(s) in the front: do nothing
+                    // Else:
+                    if (idx >= 0) {
+                        if (idx < this.borders.length) {
+                            // Insert point(s) in the middle
+                            this.borders[idx].point2 = this.vertices[start];
+                        } else {
+                            // Add point at the end
+                            start = idx;
+                        }
+                    }
                 }
-                for (i = idx + 1; i < idx + 1 + le; i++) {
+                for (i = start; i < start + le; i++) {
                     this.borders.splice(i, 0,
                         this.board.create('segment', [this.vertices[i], this.vertices[i + 1]], this.attr_line)
                     );
                 }
             }
+            this.inherits = [];
+            this.inherits.push(this.vertices, this.borders);
             this.board.update();
 
             return this;
@@ -673,7 +688,8 @@ define([
          * @returns {JXG.Polygon} Reference to the polygon
          */
         removePoints: function (p) {
-            var i, j, idx, nvertices = [], nborders = [],
+            var i, j, j0, idx, firstPoint,
+                nvertices = [], nborders = [],
                 nidx = [], partition = [];
 
             // Partition:
@@ -684,8 +700,11 @@ define([
             // this gives us the borders, that can be removed and the borders we have to create.
 
 
-            // Remove the last vertex which is identical to the first
-            this.vertices = this.vertices.slice(0, this.vertices.length - 1);
+            // In case of polygon: remove the last vertex from the list of vertices since
+            // it is identical to the first
+            if (this.elType === 'polygon') {
+                firstPoint = this.vertices.pop();
+            }
 
             // Collect all valid parameters as indices in nidx
             for (i = 0; i < arguments.length; i++) {
@@ -693,12 +712,19 @@ define([
                 if (Type.isPoint(idx)) {
                     idx = this.findPoint(idx);
                 }
-
                 if (Type.isNumber(idx) && idx > -1 && idx < this.vertices.length && Type.indexOf(nidx, idx) === -1) {
                     nidx.push(idx);
                 }
             }
 
+            if (nidx.length === 0) {
+                // Wrong index, get out of here
+                if (this.elType === 'polygon') {
+                    this.vertices.push(firstPoint);
+                }
+                return this;
+            }
+
             // Remove the polygon from each removed point's children
             for (i = 0; i < nidx.length; i++) {
                 this.vertices[nidx[i]].removeChild(this);
@@ -709,7 +735,7 @@ define([
             nvertices = this.vertices.slice();
             nborders = this.borders.slice();
 
-            // Initialize the partition
+            // Initialize the partition with an array containing the last point to be removed
             if (this.withLines) {
                 partition.push([nidx[nidx.length - 1]]);
             }
@@ -719,7 +745,9 @@ define([
             for (i = nidx.length - 1; i > -1; i--) {
                 nvertices[nidx[i]] = -1;
 
-                if (this.withLines && (nidx[i] - 1 > nidx[i - 1])) {
+                // Find gaps between the list of points to be removed.
+                // In this case a new partition is added.
+                if (this.withLines && nidx.length > 1 && (nidx[i] - 1 > nidx[i - 1])) {
                     partition[partition.length - 1][1] = nidx[i];
                     partition.push([nidx[i - 1]]);
                 }
@@ -737,7 +765,11 @@ define([
                     this.vertices.push(nvertices[i]);
                 }
             }
-            if (this.vertices[this.vertices.length - 1].id !== this.vertices[0].id) {
+
+            // Close the polygon again
+            if (this.elType === 'polygon' &&
+                this.vertices.length > 1 &&
+                this.vertices[this.vertices.length - 1].id !== this.vertices[0].id) {
                 this.vertices.push(this.vertices[0]);
             }
 
@@ -747,23 +779,28 @@ define([
                     for (j = partition[i][1] - 1; j < partition[i][0] + 1; j++) {
                         // special cases
                         if (j < 0) {
-                            // first vertex is removed, so the last border has to be removed, too
-                            j = 0;
-                            this.board.removeObject(this.borders[nborders.length - 1]);
-                            nborders[nborders.length - 1] = -1;
-                        } else if (j > nborders.length - 1) {
-                            j = nborders.length - 1;
+                            if (this.elType === 'polygon') {
+                                // First vertex is removed, so the last border has to be removed, too
+                                this.board.removeObject(this.borders[nborders.length - 1]);
+                                nborders[nborders.length - 1] = -1;
+                            }
+                        } else if (j < nborders.length) {
+                            this.board.removeObject(this.borders[j]);
+                            nborders[j] = -1;
                         }
-
-                        this.board.removeObject(this.borders[j]);
-                        nborders[j] = -1;
                     }
 
-                    // only create the new segment if it's not the closing border. the closing border is getting a special treatment at the end
-                    // the if clause is newer than the min/max calls inside createSegment; i'm sure this makes the min/max calls obsolete, but
-                    // just to be sure...
+                    // Only create the new segment if it's not the closing border.
+                    // The closing border is getting a special treatment at the end.
                     if (partition[i][1] !== 0 && partition[i][0] !== nvertices.length - 1) {
-                        nborders[partition[i][0] - 1] = this.board.create('segment', [nvertices[Math.max(partition[i][1] - 1, 0)], nvertices[Math.min(partition[i][0] + 1, this.vertices.length - 1)]], this.attr_line);
+                        // nborders[partition[i][0] - 1] = this.board.create('segment', [
+                        //             nvertices[Math.max(partition[i][1] - 1, 0)],
+                        //             nvertices[Math.min(partition[i][0] + 1, this.vertices.length - 1)]
+                        //         ], this.attr_line);
+                        nborders[partition[i][0] - 1] = this.board.create('segment', [
+                            nvertices[partition[i][1] - 1],
+                            nvertices[partition[i][0] + 1]
+                        ], this.attr_line);
                     }
                 }
 
@@ -775,10 +812,16 @@ define([
                 }
 
                 // if the first and/or the last vertex is removed, the closing border is created at the end.
-                if (partition[0][1] === this.vertices.length - 1 || partition[partition.length - 1][1] === 0) {
-                    this.borders.push(this.board.create('segment', [this.vertices[0], this.vertices[this.vertices.length - 2]], this.attr_line));
+                if (this.elType === 'polygon' &&
+                    this.vertices.length > 2 &&  // Avoid trivial case of polygon with 1 vertex
+                    (partition[0][1] === this.vertices.length - 1 || partition[partition.length - 1][1] === 0)) {
+                    this.borders.push(this.board.create('segment',
+                            [this.vertices[0], this.vertices[this.vertices.length - 2]],
+                            this.attr_line));
                 }
             }
+            this.inherits = [];
+            this.inherits.push(this.vertices, this.borders);
 
             this.board.update();
 
@@ -1025,7 +1068,6 @@ define([
             return this.sutherlandHodgman(polygon);
         }
 
-
     });