mapping-component-package-jp 0.0.2

package/src/js/fieldEncapsulation/iql.fieldvalidator.js

@@ -0,0 +1,574 @@
+/*
+ * Field Validator Object
+*/
+import polyline from 'polyline';
+
+export class FieldValidator {
+    static geoJSON2GoogleLatLng(boundaries) {
+        return boundaries.map(point => new google.maps.LatLng(point[1], point[0]));
+    }
+
+    static calcIntersection(polyOne, polyTwo) {
+        const polygon1 = new google.maps.Polygon({
+            paths: polyOne.map(p => new google.maps.LatLng(p[1], p[0]))
+        });
+        const polygon2 = new google.maps.Polygon({
+            paths: polyTwo.map(p => new google.maps.LatLng(p[1], p[0]))
+        });
+
+        // Check if any point of polygon2 is inside polygon1
+        for (let i = 0; i < polyTwo.length; i++) {
+            const point = new google.maps.LatLng(polyTwo[i][1], polyTwo[i][0]);
+            if (google.maps.geometry.poly.containsLocation(point, polygon1)) {
+                return true;
+            }
+        }
+
+        // Check if any point of polygon1 is inside polygon2
+        for (let i = 0; i < polyOne.length; i++) {
+            const point = new google.maps.LatLng(polyOne[i][1], polyOne[i][0]);
+            if (google.maps.geometry.poly.containsLocation(point, polygon2)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    static findSelfIntersects(geoJsonPolygon) {
+        const path = geoJsonPolygon.map(point => new google.maps.LatLng(point[1], point[0]));
+        const polygon = new google.maps.Polygon({ paths: path });
+        
+        // Check for self-intersections by comparing segments
+        const intersectionPoints = [];
+        
+        for (let i = 0; i < path.length - 1; i++) {
+            for (let j = i + 2; j < path.length - 1; j++) {
+                // Skip adjacent segments
+                if (i === 0 && j === path.length - 2) continue;
+                
+                const seg1 = [path[i], path[i + 1]];
+                const seg2 = [path[j], path[j + 1]];
+                
+                if (this.segmentsIntersect(
+                    seg1[0].lat(), seg1[0].lng(),
+                    seg1[1].lat(), seg1[1].lng(),
+                    seg2[0].lat(), seg2[0].lng(),
+                    seg2[1].lat(), seg2[1].lng()
+                )) {
+                    // Calculate intersection point (approximate)
+                    const midPoint = new google.maps.LatLng(
+                        (seg1[0].lat() + seg1[1].lat()) / 2,
+                        (seg1[0].lng() + seg1[1].lng()) / 2
+                    );
+                    intersectionPoints.push([midPoint.lng(), midPoint.lat()]);
+                }
+            }
+        }
+        
+        return intersectionPoints;
+    }
+
+    static segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4) {
+        const ccw = (x1, y1, x2, y2, x3, y3) => {
+            return (y3 - y1) * (x2 - x1) > (y2 - y1) * (x3 - x1);
+        };
+        
+        return (ccw(x1, y1, x3, y3, x4, y4) !== ccw(x2, y2, x3, y3, x4, y4)) &&
+               (ccw(x1, y1, x2, y2, x3, y3) !== ccw(x1, y1, x2, y2, x4, y4));
+    }
+
+    // Completes the shape path start point equals to end point
+    static path_convert(shape) {
+        var newShape = shape;
+        if (newShape[shape.length-1] !== newShape[0]) {
+            newShape[shape.length] = newShape[0];
+        }
+    
+        return (newShape);
+    }
+
+    // Checks if google geometnry API is available
+    static checkGoogleAPI() {
+        try {
+            google.maps.geometry;
+        } catch (e) {
+            throw new Error('Google Maps API is Required');
+        }
+    }
+
+    // Decode shape coordinates
+    static decodeShapes_get(encodedShapes) {
+        var shapes_splited = [];
+
+        encodedShapes.forEach(function (shape, polyindex) {
+            shapes_splited.push(shape.path);
+        });
+
+        var shapesPath = [];
+        var path = [];
+
+        shapes_splited.forEach(function (poly, pIndex) {
+            path = polyline.decode(poly);
+            shapesPath.push(path);
+        });
+
+        return (shapesPath);
+    }
+
+    // Convert array of point into google LatLng
+    static pathToGoogleLatLng_get(shapesPath) {
+        var paths_googleLatLng = [];
+        var path_googleLatLng = [];
+
+        shapesPath.forEach(function (poly, polyindex) {
+            path_googleLatLng = [];
+
+            poly.forEach(function (c, cindex) {
+                path_googleLatLng.push(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])));
+            });
+
+            paths_googleLatLng.push(path_googleLatLng);
+        });
+
+        return (paths_googleLatLng);
+    }
+
+    // Checks if all the holes inside the outershape 
+    static holesOutsideOuterShape_check(shapesPath, paths_googleLatLng) {
+        var outerPoly = new google.maps.Polygon({
+            path: paths_googleLatLng[0]
+        });
+
+        var pointsNotInside_count = 0;
+        var shapesOutside = 0;
+
+        shapesPath.forEach(function (poly, polyindex) {
+            if (polyindex > 0) {
+                poly.forEach(function (c, cindex) {
+                    if (!google.maps.geometry.poly.containsLocation(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])), outerPoly)) {
+                        pointsNotInside_count++;
+                    }
+                });
+                if (pointsNotInside_count == poly.length) {
+                    shapesOutside++;
+                }
+                pointsNotInside_count = 0;
+            }
+        });
+
+        return (shapesOutside > 0);
+    }
+
+    // Returns true if one of the shapes path has a self intersection.
+    static selfInterceptionShape_check(shapesPath) {
+        var invalidPoints = 0;
+        var selfInterceptionCount = 0;
+        
+        shapesPath.forEach(function (poly, polyindex) {
+            // check self-intersection
+
+            invalidPoints = FieldValidator.findSelfIntersects(FieldValidator.path_convert(poly));
+            selfInterceptionCount += invalidPoints.length;
+        });
+
+        return (selfInterceptionCount > 0)
+    }
+
+    // Check if all the all the holes are inside the outer polygon
+    static holesInterceptOuterShape_check(shapesPath, paths_googleLatLng) {
+        // check if holes are inside outer polygon    
+        var outerPoly = new google.maps.Polygon({
+            path: paths_googleLatLng[0]
+        });
+
+        var notInsideCount = 0;
+        var shapesInterceptOutside = 0;
+
+        shapesPath.forEach(function (poly, polyindex) {
+            if (polyindex > 0) {
+                poly.forEach(function (c, cindex) {
+                    if (!google.maps.geometry.poly.containsLocation(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])), outerPoly)) {
+                        notInsideCount++;
+                    }
+                });
+                if (notInsideCount > 0 && notInsideCount < poly.length) {
+                    shapesInterceptOutside++;
+                }
+                notInsideCount = 0;
+            }
+        });
+
+        return (shapesInterceptOutside == 0);
+    }
+
+    // Check if holes intersect between each other
+    static holesIntercept_check(shapesPath, paths_googleLatLng) {
+        var holeIntersectCount = 0;
+
+        for (var i = 1; i < paths_googleLatLng.length - 1; i++) {
+            for (var j = i + 1; j < paths_googleLatLng.length; j++) {
+                if (FieldValidator.calcIntersection(FieldValidator.path_convert(shapesPath[i]), FieldValidator.path_convert(shapesPath[j]))) {
+                    holeIntersectCount++;
+                }
+            }
+        }
+
+        return (holeIntersectCount > 0);
+    }
+
+    // Validates coordinates
+    static coordinatesValidate(coordinates, polygonType) {
+
+        FieldValidator.checkGoogleAPI();
+
+        var isValid = false;
+        var errorMessage = '';
+        var encodedField = '';
+
+        if (polygonType == 'Polygon') {
+            if (coordinates.length > 0) {
+                polycoords = coordinates;
+                // check if any of the shapes has less then three vertices (four coordinates)
+                invalidVerticesCount = 0;
+
+                polycoords.forEach(poly => {
+                    if (poly.length < 4) {
+                        invalidVerticesCount++;
+                    }
+                });
+
+                if (invalidVerticesCount == 0) {
+                    // check if first and last coordinate are the same 
+                    invalidStartEndCount = 0;
+
+                    polycoords.forEach(function (poly, polyindex) {
+                        if (poly[0][0] != poly[poly.length - 1][0] || poly[0][1] != poly[poly.length - 1][1]) {
+                            invalidStartEndCount++;
+                        }
+                    });
+
+                    if (invalidStartEndCount == 0) {
+                        selfIntersectionCount = 0;
+
+                        polycoords.forEach(function (poly, polyindex) {
+                            // check self-intersection
+                            invalidPoints = FieldValidator.findSelfIntersects(poly);
+                            selfIntersectionCount += invalidPoints.length;
+                        });
+
+                        if (selfIntersectionCount == 0) {
+                            paths = [];
+                            // check orientation of outer and inner polygons using signed area
+                            invalidOrientationCount = 0;
+
+                            polycoords.forEach(function (poly, polyindex) {
+                                path = [];
+
+                                poly.forEach(function (c, cindex) {
+                                    path.push(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])));
+                                });
+
+                                signedArea = google.maps.geometry.spherical.computeSignedArea(path);
+								console.log('signedArea before: '+signedArea);
+								
+								if (polyindex == 0 && signedArea > 0) {
+									path.reverse();
+                                    //invalidOrientationCount++;
+									//path.reverse();
+                                    //invalidOrientationCount--;
+                                }
+                                if (polyindex > 0 && signedArea < 0) {
+                                    //invalidOrientationCount++;
+									path.reverse();
+                                    //invalidOrientationCount--;
+                                }
+
+                                signedArea = google.maps.geometry.spherical.computeSignedArea(path);
+								console.log('signedArea after: '+signedArea);
+								if (polyindex == 0 && signedArea > 0) {
+                                    invalidOrientationCount++;
+								}
+                                if (polyindex > 0 && signedArea < 0) {
+                                    invalidOrientationCount++;
+								}				
+                                paths.push(path);
+                            });
+
+                            if (invalidOrientationCount == 0) {
+                                if (paths.length == 1) {
+                                    encodedField = google.maps.geometry.encoding.encodePath(paths[0]);
+                                    isValid = true;
+                                }
+                                else if (paths.length > 1) {
+                                    // check if holes are inside outer polygon    
+                                    outerPoly = new google.maps.Polygon({
+                                        path: paths[0]
+                                    });
+                                    notInsideCount = 0;
+                                    polycoords.forEach(function (poly, polyindex) {
+                                        if (polyindex > 0) {
+                                            poly.forEach(function (c, cindex) {
+                                                if (!google.maps.geometry.poly.containsLocation(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])), outerPoly)) {
+                                                    notInsideCount++;
+                                                }
+                                            });
+                                        }
+                                    });
+                                    //console.log('Polygon notInsideCount: '+notInsideCount);
+
+                                    if (notInsideCount == 0) {
+                                        console.log('Polygon paths.length: ' + paths.length);
+                                        if (paths.length == 2) {
+                                            encodedPath = '';
+                                            polycoords.forEach(function (poly, polyindex) {
+                                                path = [];
+                                                poly.forEach(function (c, cindex) {
+                                                    path.push(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])));
+                                                });
+                                                encodedPath += google.maps.geometry.encoding.encodePath(path) + ',';
+                                            });
+
+                                            encodedField = encodedPath.substr(0, encodedPath.length - 1);
+                                            isValid = true;
+
+                                        }
+                                        else if (paths.length > 2) {
+                                            // check if holes don't intersect each other if there is more than one hole
+                                            holeIntersectCount = 0;
+                                            //var combis = [];
+
+                                            for (var i = 1; i < paths.length - 1; i++) {
+                                                for (var j = i + 1; j < paths.length; j++) {
+                                                    if (FieldValidator.calcIntersection(polycoords[i], polycoords[j])) {
+                                                        holeIntersectCount++;
+                                                    }
+                                                }
+                                            }
+
+                                            if (holeIntersectCount == 0) {
+                                                encodedPath = '';
+                                                polycoords.forEach(function (poly, polyindex) {
+                                                    path = [];
+                                                    poly.forEach(function (c, cindex) {
+                                                        path.push(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])));
+                                                    });
+                                                    encodedPath += google.maps.geometry.encoding.encodePath(path) + ',';
+                                                });
+                                                isValid = true;
+                                                encodedField = encodedPath.substr(0, encodedPath.length - 1);
+
+                                            } else {
+                                                errorMessage = 'At least two holes intersect';
+                                            }
+                                        }
+                                    } else {
+                                        errorMessage = 'At least one hole intersects with the outer polygon';
+                                    }
+                                }
+                            } else {
+                                errorMessage = 'The uploaded polygon(s) have an invalid orientation';
+                            }
+                        } else {
+                            errorMessage = 'There is self-intersection in the uploaded polygon(s)';
+                        }
+                    } else {
+                        errorMessage = 'The path of the uploaded polygon(s) is not complete';
+                    }
+                } else {
+                    errorMessage = 'There is an insufficient amount of vertices in at least one of the uploaded polygon(s)';
+                }
+            } else {
+                errorMessage = 'There are no coordinates for the uploaded polygon';
+            }
+        }
+        else if (polygonType == 'MultiPolygon') {
+            if (coordinates.length > 1) {
+                errorMessage = 'There is more than one outer polygon';
+            } else if (coordinates.length == 1) {
+                if (coordinates[0].length > 0) {
+                    polycoords = coordinates[0];
+                    // check if any of the shapes has less then three vertices (four coordinates)
+                    invalidVerticesCount = 0;
+                    polycoords.forEach(function (poly, polyindex) {
+                        console.log('MP polyindex: ' + polyindex);
+                        console.log('MP poly.length: ' + poly.length);
+                        if (poly.length < 4) {
+                            invalidVerticesCount++;
+                        }
+                    });
+
+                    if (invalidVerticesCount == 0) {
+                        // check if first and last coordinate are the same 
+                        invalidStartEndCount = 0;
+                        polycoords.forEach(function (poly, polyindex) {
+                            if (poly[0][0] != poly[poly.length - 1][0] || poly[0][1] != poly[poly.length - 1][1]) {
+                                invalidStartEndCount++;
+                            }
+                        });
+                        if (invalidStartEndCount == 0) {
+                            selfIntersectionCount = 0;
+                            polycoords.forEach(function (poly, polyindex) {
+                                // check self-intersection
+                                invalidPoints = FieldValidator.findSelfIntersects(poly);
+                                selfIntersectionCount += invalidPoints.length;
+                            });
+                            if (selfIntersectionCount == 0) {
+                                paths = [];
+                                // check orientation of outer and inner polygons using signed area
+                                invalidOrientationCount = 0;
+                                polycoords.forEach(function (poly, polyindex) {
+                                    path = [];
+                                    poly.forEach(function (c, cindex) {
+                                        path.push(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])));
+                                    });
+                                    signedArea = google.maps.geometry.spherical.computeSignedArea(path);
+                                    if (polyindex == 0 && signedArea > 0) {
+                                        path.reverse();
+                                    }
+                                    if (polyindex > 0 && signedArea < 0) {
+                                        path.reverse();
+                                    }
+                                    signedArea = google.maps.geometry.spherical.computeSignedArea(path);
+                                    if (polyindex == 0 && signedArea > 0) {
+                                        invalidOrientationCount++;
+                                    }
+                                    if (polyindex > 0 && signedArea < 0) {
+                                        invalidOrientationCount++;
+                                    }
+                                    paths.push(path);
+                                });
+
+                                if (invalidOrientationCount == 0) {
+                                    if (paths.length == 1) {
+                                        encodedField = google.maps.geometry.encoding.encodePath(paths[0]);
+                                        isValid = true;
+                                    } else if (paths.length > 1) {
+                                        // check if holes are inside outer polygon    
+                                        outerPoly = new google.maps.Polygon({
+                                            path: paths[0]
+                                        });
+                                        notInsideCount = 0;
+                                        polycoords.forEach(function (poly, polyindex) {
+                                            if (polyindex > 0) {
+                                                poly.forEach(function (c, cindex) {
+                                                    if (!google.maps.geometry.poly.containsLocation(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])), outerPoly)) {
+                                                        notInsideCount++;
+                                                    }
+                                                });
+                                            }
+                                        });
+                                        //console.log('Polygon notInsideCount: '+notInsideCount);
+
+                                        if (notInsideCount == 0) {
+                                            console.log('Polygon paths.length: ' + paths.length);
+                                            if (paths.length == 2) {
+                                                encodedPath = '';
+                                                polycoords.forEach(function (poly, polyindex) {
+                                                    path = [];
+                                                    poly.forEach(function (c, cindex) {
+                                                        path.push(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])));
+                                                    });
+                                                    encodedPath += google.maps.geometry.encoding.encodePath(path) + ',';
+                                                });
+                                                encodedField = encodedPath.substr(0, encodedPath.length - 1);
+                                                isValid = true;
+
+                                            } else if (paths.length > 2) {
+                                                // check if holes don't intersect each other if there is more than one hole
+                                                holeIntersectCount = 0;
+                                                //var combis = [];
+                                                for (var i = 1; i < paths.length - 1; i++) {
+                                                    for (var j = i + 1; j < paths.length; j++) {
+                                                        if (calcIntersection(polycoords[i], polycoords[j])) {
+                                                            holeIntersectCount++;
+                                                        }
+                                                    }
+                                                }
+                                                if (holeIntersectCount == 0) {
+                                                    encodedPath = '';
+                                                    polycoords.forEach(function (poly, polyindex) {
+                                                        path = [];
+                                                        poly.forEach(function (c, cindex) {
+                                                            path.push(new google.maps.LatLng(parseFloat(c[1]), parseFloat(c[0])));
+                                                        });
+                                                        encodedPath += google.maps.geometry.encoding.encodePath(path) + ',';
+                                                    });
+                                                    encodedField = encodedPath.substr(0, encodedPath.length - 1);
+                                                    isValid = true
+
+                                                } else {
+                                                    errorMessage = 'At least two holes intersect';
+                                                }
+                                            }
+                                        } else {
+                                            errorMessage = 'At least one hole intersects with the outer polygon';
+                                        }
+                                    }
+                                } else {
+                                    errorMessage = 'The uploaded polygon(s) have an invalid orientation';
+                                }
+                            } else {
+                                errorMessage = 'There is self-intersection in the uploaded polygon(s)';
+                            }
+                        } else {
+                            errorMessage = 'The path of the uploaded polygon(s) is not complete';
+                        }
+                    } else {
+                        errorMessage = 'There is an insufficient amount of vertices in at least one of the uploaded polygon(s)';
+                    }
+                } else {
+                    errorMessage = 'There are no coordinates for the uploaded polygon(s)';
+                }
+            } else {
+                errorMessage = 'There are no coordinates for the uploaded polygon(s)';
+            }
+
+        }
+
+        return {
+            'isValid': isValid,
+            'errorMessage': errorMessage,
+            'encodedField': encodedField
+        }
+    }
+
+    // Validates field
+    static mapFieldsValidate(encodedShapes) {
+
+        FieldValidator.checkGoogleAPI();
+        var errorMessage = '';
+
+        // Decoded shapes 
+        var shapesPath = FieldValidator.decodeShapes_get(encodedShapes);
+
+        var paths_googleLatLng = FieldValidator.pathToGoogleLatLng_get(shapesPath);
+
+        if (shapesPath.length > 0 ) {
+            // Checks if any of the listed shapes has a selfintersection
+            if (!FieldValidator.selfInterceptionShape_check(shapesPath)) {
+                // Checks if every hole is outside the outer shape
+                if (!FieldValidator.holesOutsideOuterShape_check(shapesPath, paths_googleLatLng)) {
+                    // Checks if every hole is inside the outer shape
+                    if (FieldValidator.holesInterceptOuterShape_check(shapesPath, paths_googleLatLng)) {
+                        if (paths_googleLatLng.length > 2) {
+                            // Check if holes don't intersect each other if there is more than one hole
+                            if (!FieldValidator.holesIntercept_check(shapesPath, paths_googleLatLng)) {
+                            } else {
+                                errorMessage = 'ShapeInterceptingShape';
+                            }
+                        }
+                    } else {
+                        errorMessage = 'ShapeOutsideOutterShape';
+                    }
+                } else {
+                    errorMessage = 'ShapeOutsideOutterShape';
+                }
+
+            } else {
+                errorMessage = 'InterceptShapes';
+            }
+        }
+        return (errorMessage);
+    }
+}

package/src/js/mapEncapsulation/circle.functions.js

@@ -0,0 +1,30 @@
+function toRadians(angleInDegrees) {
+    return (angleInDegrees * Math.PI) / 180;
+}
+
+function toDegrees(angleInRadians) {
+    return (angleInRadians * 180) / Math.PI;
+}
+
+function offset(c1, distance, bearing) {
+    var lat1 = toRadians(c1[1]);
+    var lon1 = toRadians(c1[0]);
+    var dByR = distance / 6378137;
+    var lat = Math.asin(Math.sin(lat1) * Math.cos(dByR) + Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing));
+    var lon = lon1 + Math.atan2(Math.sin(bearing) * Math.sin(dByR) * Math.cos(lat1), Math.cos(dByR) - Math.sin(lat1) * Math.sin(lat));
+    return new google.maps.LatLng({ lat: toDegrees(lat), lng: toDegrees(lon) });
+}
+
+function circleToPolygon(center, radius, numberOfWaypoints, isHole) {
+    var coordinates = [];
+    for (var i = 0; i < numberOfWaypoints; ++i) {
+        coordinates.push(offset(center, radius, (2 * Math.PI * - i) / numberOfWaypoints));
+    }
+    if (isHole) {
+        return coordinates;
+    } else {
+        return coordinates.reverse();
+    }
+}
+
+export { toRadians, toDegrees, offset, circleToPolygon };

package/src/js/mapEncapsulation/field.geolocation.js

@@ -0,0 +1,19 @@
+export class IQLFieldGeoLocation {
+    
+    IsValid = '';
+    Poly = '';
+    Area = 0;
+    Perimeter = 0;
+    Latitude = 0;
+    Longitude = 0;
+
+    constructor(path, area, perimeter, latitude, longitude, IsValid) {
+        this.Poly = path;
+        this.Area = area;
+        this.Perimeter = perimeter;
+        this.Latitude = latitude;
+        this.Longitude = longitude;
+        this.IsValid = IsValid;
+        this.GeoJSON = undefined;
+    }
+}