"use strict;"
|
//
|
//---- Global variables -----
|
//
|
var g_OperationParameters = null;
|
//
|
// * g_NumWaypoints is being used to count waypoints added
|
// in order to decide whether the user passed the predefined quota.
|
//
|
var g_NumWaypoints = 0;
|
var g_KeepAskingIfTooManyPoints = true;
|
//
|
// * g_MinSlopeDiff is used to determine the minimum difference in grade
|
// that we'll use to remove extra waypoints
|
//
|
var g_MinSlopeDiff = 0.01;
|
//
|
// * g_MaxHeadingDiff is used to determine whether a pair of lines is turning
|
// ie: this is the threshold for a course change
|
//
|
var g_MaxHeadingDiff = 0.5;
|
//
|
// * g_Flatten determines whether to implement wall top flattening routine
|
//
|
//
|
var g_Flatten = true;
|
|
//Enumeration-style globals
|
var OBJECTTYPE = {
|
"MeshFence": 0,
|
"Wall": 1,
|
"WallWithFence": 2,
|
"WireStrandFence": 3
|
};
|
|
var CREATEAS = {
|
"Group": 0,
|
"Layer_Entire": 1,
|
"Layer_Streaming": 2
|
};
|
|
var FILLSTYLE = {
|
"Color": 0,
|
"Texture": 1
|
};
|
|
var POSTSTYLE = {
|
"None": 0,
|
"Circular": 1,
|
"Square": 2
|
};
|
|
var TYPE_FENCE = OBJECTTYPE.MeshFence;
|
var TYPE_WALL = OBJECTTYPE.Wall;
|
var TYPE_WALLWITHFENCE = OBJECTTYPE.WallWithFence;
|
|
// note that "PostReference" is added dynamically because it's just getting reset every time the paramters object gets looped...
|
// probably it could be placed as a parameter in WorkingGroup more appropriately, but it's just not done that way for now
|
|
//Default Parameter Objects
|
var DEFAULT_FENCE_PARAMS =
|
{
|
ObjectType: OBJECTTYPE.MeshFence,
|
CreateAs: CREATEAS.Layer_Streaming,
|
FillStyle: FILLSTYLE.Color,
|
Color: "#808080",
|
Opacity: 50,
|
Texture: SGLang.i18n("Select_A_File"),
|
Height: 2,
|
Sampling: 5,
|
SimplifyLine: false,
|
PostStyle: POSTSTYLE.Circular,
|
PostFillStyle: FILLSTYLE.Color,
|
PostColor: "#808080",
|
PostTexture: SGLang.i18n("Select_A_File"),
|
PostSpacing: 5,
|
PostExtension: 0.25,
|
PostDiameter: 0.2,
|
VisibilityDistance: 5000,
|
MaxWaypoints: 2000
|
};
|
var DEFAULT_WALL_PARAMS =
|
{
|
ObjectType: OBJECTTYPE.Wall,
|
CreateAs: CREATEAS.Layer_Streaming,
|
FillStyle: FILLSTYLE.Color,
|
Color: "#404040",
|
Opacity: 100,
|
Texture: SGLang.i18n("Select_A_File"),
|
Width: 0.5,
|
Height: 5,
|
Sampling: 5,
|
SimplifyLine: false,
|
PostStyle: POSTSTYLE.None,
|
PostFillStyle: FILLSTYLE.Color,
|
PostColor: "#000000",
|
PostTexture: SGLang.i18n("Select_A_File"),
|
PostSpacing: 5,
|
PostExtension: 0.25,
|
PostDiameter: 0.25,
|
VisibilityDistance: 5000,
|
MaxWaypoints: 2000
|
};
|
|
var DEFAULT_WALLWITHFENCE_PARAMS =
|
{
|
ObjectType: OBJECTTYPE.WallWithFence,
|
CreateAs: CREATEAS.Layer_Streaming,
|
WallParameters: {},
|
FenceParameters: {}
|
};
|
|
$.extend(DEFAULT_WALLWITHFENCE_PARAMS.WallParameters, DEFAULT_WALL_PARAMS);
|
DEFAULT_WALLWITHFENCE_PARAMS.WallParameters.CreateAs = DEFAULT_WALLWITHFENCE_PARAMS.CreateAs;
|
$.extend(DEFAULT_WALLWITHFENCE_PARAMS.FenceParameters, DEFAULT_FENCE_PARAMS);
|
DEFAULT_WALLWITHFENCE_PARAMS.FenceParameters.CreateAs = DEFAULT_WALLWITHFENCE_PARAMS.CreateAs;
|
DEFAULT_WALLWITHFENCE_PARAMS.FenceParameters.Height = DEFAULT_WALLWITHFENCE_PARAMS.WallParameters.Height + 2;
|
DEFAULT_WALLWITHFENCE_PARAMS.FenceParameters.PostStyle = POSTSTYLE.Circular;
|
|
var DEFAULT_WIRESTRAND_PARAMS =
|
{
|
ObjectType: OBJECTTYPE.WireStrandFence,
|
CreateAs: CREATEAS.Layer_Streaming,
|
NumberOfStrands: 3,
|
FillStyle: FILLSTYLE.Color,
|
Color: "#808080",
|
Opacity: 100,
|
Height: 3,
|
Sampling: 5,
|
SimplifyLine: false,
|
PostStyle: POSTSTYLE.Circular,
|
PostFillStyle: FILLSTYLE.Color,
|
PostColor: "#808080",
|
PostTexture: SGLang.i18n("Select_A_File"),
|
PostSpacing: 5,
|
PostExtension: 0,
|
PostDiameter: 0.2,
|
VisibilityDistance: 5000,
|
MaxWaypoints: 2000
|
};
|
|
function ValidateParameters(params)
|
{
|
if (params == null)
|
{
|
return false;
|
}
|
if (params.PostSpacing < params.Sampling) {
|
alert(SGLang.i18n("ERROR_TEXT_SamplingFenceAndPosts"));
|
return false;
|
}
|
//Object Type
|
switch (params.ObjectType)
|
{
|
case OBJECTTYPE.MeshFence:
|
return ValidateFenceParams(params);
|
break;
|
case OBJECTTYPE.Wall:
|
return ValidateWallParams(params);
|
break;
|
case OBJECTTYPE.WallWithFence:
|
return ValidateWallWithFenceParams(params);
|
break;
|
case OBJECTTYPE.WireStrandFence:
|
return ValidateWireStrandFenceParams(params);
|
break;
|
default:
|
return false;
|
}
|
|
return true;
|
}
|
|
function ValidateGeneralParams(params) {
|
|
if (params.PostFillStyle == FILLSTYLE.Texture && (params.PostTexture == SGLang.i18n("Select_A_File") || params.PostTexture == "")) {
|
alert(SGLang.i18n("ERROR_TEXT_NoPostTexture"));
|
return false;
|
}
|
|
// check all common numerics here... isNaN and appropriate ranges
|
if (isNaN(params.Opacity) || params.Opacity < 0 || params.Opacity > 100){
|
alert(SGLang.i18n("ERROR_TEXT_OpacityValidation"));
|
return false;
|
}
|
|
if (isNaN(params.Sampling) || params.Sampling < 1){
|
alert(SGLang.i18n("ERROR_TEXT_SamplingValidation"));
|
return false;
|
}
|
|
if (isNaN(params.PostSpacing) || params.PostSpacing < 0) {
|
alert(SGLang.i18n("ERROR_TEXT_PostSpacingValidation"));
|
return false;
|
}
|
|
if (isNaN(params.PostExtension) || params.PostExtension < 0) {
|
alert(SGLang.i18n("ERROR_TEXT_PostExtensionValidation"));
|
return false;
|
}
|
|
if (isNaN(params.PostDiameter) || params.PostDiameter < 0) {
|
alert(SGLang.i18n("ERROR_TEXT_PostDiameterValidation"));
|
return false;
|
}
|
|
if (isNaN(params.VisibilityDistance) || params.VisibilityDistance < 1) {
|
alert(SGLang.i18n("ERROR_TEXT_VisibilityDistanceValidation"));
|
return false;
|
}
|
|
//
|
// If you got here safe then return true
|
//
|
return true;
|
}
|
|
function ValidateFenceParams(params) {
|
if (params.FillStyle == FILLSTYLE.Texture && params.Texture == SGLang.i18n("Select_A_File")) {
|
alert(SGLang.i18n("ERROR_TEXT_NoTexture"));
|
return false;
|
}
|
|
if (isNaN(params.Height) || params.Height < 0.5) {
|
alert(SGLang.i18n("ERROR_TEXT_FenceHeightValidation"));
|
return false;
|
}
|
|
if (!ValidateGeneralParams(params))
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
function ValidateWallParams(params) {
|
if (params.FillStyle == FILLSTYLE.Texture && params.Texture == SGLang.i18n("Select_A_File")) {
|
alert(SGLang.i18n("ERROR_TEXT_NoTexture"));
|
return false;
|
}
|
|
if (isNaN(params.Width) || params.Width < 0.01) {
|
alert(SGLang.i18n("ERROR_TEXT_WallWidthValidation"));
|
return false;
|
}
|
|
if ( isNaN(params.Height) || params.Height < 0.5 ) {
|
alert(SGLang.i18n("ERROR_TEXT_WallHeightValidation"));
|
return false;
|
}
|
|
if (!ValidateGeneralParams(params))
|
{
|
return false;
|
}
|
//
|
// If you got here safe then return true
|
//
|
return true;
|
}
|
|
function ValidateWallWithFenceParams(params) {
|
if (ValidateWallParams(params.WallParameters) && ValidateFenceParams(params.FenceParameters))
|
{
|
return true;
|
}
|
return false;
|
}
|
|
function ValidateWireStrandFenceParams(params) {
|
if (isNaN(params.NumberOfStrands) || params.NumberOfStrands < 0) {
|
alert(SGLang.i18n("ERROR_TEXT_TooFewStrands"));
|
return false;
|
}
|
|
if (isNaN(params.Height) || params.Height < 0.5) {
|
alert(SGLang.i18n("ERROR_TEXT_WireStrandHeightValidation"));
|
return false;
|
}
|
|
if (!ValidateGeneralParams(params))
|
{
|
return false;
|
}
|
|
//
|
// If you got here safe then return true
|
//
|
return true;
|
}
|
|
////////////// Class ClassCreateLayerOrGroupInfo
|
//
|
// Constructor for Group or Layer creation helper class
|
//
|
function ClassCreateLayerOrGroupInfo() {
|
this.IsGroup = false;
|
this.CreateItemCallback = null;
|
this.FinalizationCallback = null;
|
this.LayerOrGroupObject = null;
|
}
|
//
|
// Function pointers
|
//
|
ClassCreateLayerOrGroupInfo.prototype.Create = CreateALayerOrGroup;
|
|
function CreateALayerOrGroup() {
|
switch (g_OperationParameters.CreateAs) {
|
case CREATEAS.Group:
|
var theCreatedObject = SGWorld.ProjectTree.CreateGroup(GetCreatedGroupName());
|
this.IsGroup = true;
|
this.CreateItemCallback = callbackAddItemToGroup;
|
this.FinalizationCallback = null;
|
this.LayerOrGroupObject = theCreatedObject;
|
break;
|
|
case CREATEAS.Layer_Entire:
|
case CREATEAS.Layer_Streaming:
|
var baseLayerName = GetCreatedLayerName();
|
if (g_OperationParameters.ObjectType == OBJECTTYPE.WallWithFence)
|
{
|
//creating a wall-and-fence type object requires multiple feature layers; LayerOrGroupObject is an array, with
|
//LayerOrGroupObject[0] being the wall and LayerOrGroupObject[1] being the fence
|
this.LayerOrGroupObject = [];
|
|
var wallLayer = CreateAShapeLayer(baseLayerName + " (Wall)", g_OperationParameters.CreateAs, TYPE_WALL);
|
SetCommonPropertiesForACreatedLayer(wallLayer, g_OperationParameters.WallParameters);
|
var fenceLayer = CreateAShapeLayer(baseLayerName + " (Fence)", g_OperationParameters.CreateAs, TYPE_FENCE);
|
SetCommonPropertiesForACreatedLayer(fenceLayer, g_OperationParameters.FenceParameters);
|
this.LayerOrGroupObject.push(wallLayer);
|
this.LayerOrGroupObject.push(fenceLayer);
|
}
|
else
|
{
|
var theCreatedObject = CreateAShapeLayer(baseLayerName, g_OperationParameters.CreateAs, g_OperationParameters.ObjectType);
|
SetCommonPropertiesForACreatedLayer(theCreatedObject, g_OperationParameters);
|
this.LayerOrGroupObject = theCreatedObject;
|
}
|
this.IsGroup = false;
|
this.CreateItemCallback = callbackAddItemToLayer;
|
this.FinalizationCallback = callbackEndOfGraphForLayer;
|
break;
|
|
default:
|
throw new Error(2000, "Unexpected layer or group option");
|
}
|
|
//this.LayerOrGroupObject = theCreatedObject;
|
}
|
|
//////////////////////////////// End of classes definition //////////////////////////////
|
//
|
//------------------------------
|
// WorkOnSelectedItem
|
//
|
function WorkOnSelectedItem() {
|
var node = SGWorld.ProjectTree.GetNextItem("", ItemCode.SELECTED);
|
|
if (node == "") {
|
alert(SGLang.i18n("ERROR_TEXT_NoItemSelected"));
|
return false;
|
}
|
else if (SGWorld.ProjectTree.IsLayer(node)) {
|
var theLayer = SGWorld.ProjectTree.GetLayer(node);
|
|
WorkOnALayerOfShapes(theLayer);
|
}
|
else if (SGWorld.ProjectTree.IsGroup(node)) {
|
if (WorkOnAGroupOfItems(node) == false)
|
alert(SGLang.i18n("Text32"));
|
}
|
else {
|
alert(SGLang.i18n("ERROR_TEXT_SelectedNotAGroupOrLayer"));
|
return false;
|
}
|
return true;
|
}
|
//
|
//
|
//
|
function WorkOnAPolygonOrPolyline(theShape, params) {
|
g_KeepAskingIfTooManyPoints = true;
|
var creatorHelper = new ClassCreateLayerOrGroupInfo();
|
creatorHelper.Create();
|
|
if (params.ObjectType == OBJECTTYPE.MeshFence ||
|
params.ObjectType == OBJECTTYPE.Wall ||
|
params.ObjectType == OBJECTTYPE.WireStrandFence)
|
{
|
params.PostReference = null;
|
var createdGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
|
theCallback = creatorHelper.CreateItemCallback;
|
thefinalizationCallback = creatorHelper.FinalizationCallback;
|
|
WorkingGraph(theShape,
|
params,
|
createdGroupOrLayer,
|
theCallback);
|
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(createdGroupOrLayer);
|
}
|
}
|
if (params.ObjectType == OBJECTTYPE.WallWithFence)
|
{
|
if (g_OperationParameters.CreateAs != CREATEAS.Group)
|
{
|
params.WallParameters.PostReference = null;
|
params.FenceParameters.PostReference = null;
|
theCallback = creatorHelper.CreateItemCallback;
|
thefinalizationCallback = creatorHelper.FinalizationCallback;
|
//TODO: Until TE API is fixed to allow creation of multiple feature groups
|
//within a TE-created feature layer, creating a wall-and-fence type object
|
//requires multiple feature layers
|
var wallLayer = creatorHelper.LayerOrGroupObject[0];
|
var fenceLayer = creatorHelper.LayerOrGroupObject[1];
|
|
//once for wall
|
WorkingGraph(theShape,
|
params.WallParameters,
|
wallLayer,
|
theCallback);
|
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(wallLayer);
|
}
|
|
//once for fence
|
WorkingGraph(theShape,
|
params.FenceParameters,
|
fenceLayer,
|
theCallback);
|
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(fenceLayer);
|
}
|
}
|
//else we're creating a group
|
else
|
{
|
params.WallParameters.PostReference = null;
|
params.FenceParameters.PostReference = null;
|
var createdGroup = creatorHelper.LayerOrGroupObject;
|
|
theCallback = creatorHelper.CreateItemCallback;
|
thefinalizationCallback = creatorHelper.FinalizationCallback;
|
|
//once for wall
|
|
WorkingGraph(theShape,
|
params.WallParameters,
|
createdGroup,
|
theCallback);
|
|
//once for fence
|
|
WorkingGraph(theShape,
|
params.FenceParameters,
|
createdGroup,
|
theCallback);
|
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(createdGroup);
|
}
|
}
|
}
|
}
|
//
|
//
|
//
|
function WorkOnAGroupOfItems(theGroupnode) {
|
g_OperationParameters.PostReference = null;
|
var createdGroupOrLayer = null;
|
var theCallback = null;
|
var thefinalizationCallback = null;
|
var helperCreated = false;
|
var polyFlag = false;
|
|
g_KeepAskingIfTooManyPoints = true;
|
var creatorHelper = new ClassCreateLayerOrGroupInfo();
|
|
//
|
// Get the first child
|
//
|
var childID = SGWorld.ProjectTree.GetNextItem(theGroupnode, ItemCode.CHILD);
|
if (childID == "")
|
return false;
|
while (childID != 0) {
|
var theObject;
|
var objectType;
|
var objectTypeValid;
|
|
try {
|
theObject = SGWorld.ProjectTree.GetObject(childID);
|
objectType = theObject.ObjectType;
|
objectTypeValid = true;
|
}
|
catch (err) {
|
objectTypeValid = false;
|
}
|
|
if (objectTypeValid) {
|
//If it is a layer set a layer callback
|
//If it is a group set a group callback
|
switch (objectType) { //1 = polyline, 2 = polygon
|
case ObjectTypeCode.OT_POLYLINE:
|
case ObjectTypeCode.OT_POLYGON:
|
polyFlag = true;
|
if (!helperCreated) {
|
//
|
// Calling Create() sets all necessary parameters.
|
//
|
creatorHelper.Create();
|
//
|
// Get the operation parameters.
|
//
|
createdGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
theCallback = creatorHelper.CreateItemCallback;
|
thefinalizationCallback = creatorHelper.FinalizationCallback;
|
|
helperCreated = true;
|
}
|
if (g_OperationParameters.ObjectType == TYPE_WALLWITHFENCE) {
|
var wallGroupOrLayer;
|
var fenceGroupOrLayer;
|
if (g_OperationParameters.CreateAs == CREATEAS.Group) {
|
//wall and fence can go in the same group
|
wallGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
fenceGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
}
|
else {
|
//wall and fence can't go in the same layer because
|
//of the issue with creating multiple feature groups
|
//in a TE-created feature layer
|
wallGroupOrLayer = creatorHelper.LayerOrGroupObject[0];
|
fenceGroupOrLayer = creatorHelper.LayerOrGroupObject[1];
|
}
|
var fenceHeight = parseFloat(g_OperationParameters.WallHeight) + parseFloat(g_OperationParameters.FenceHeight);
|
//call workinggraph twice, once for wall and once for fence
|
|
//wall
|
WorkingGraph(theObject,
|
g_OperationParameters.WallParameters,
|
wallGroupOrLayer,
|
theCallback);
|
|
//fence
|
WorkingGraph(theObject,
|
g_OperationParameters.FenceParameters,
|
fenceGroupOrLayer,
|
theCallback);
|
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(wallGroupOrLayer);
|
thefinalizationCallback(fenceGroupOrLayer);
|
}
|
}
|
else {
|
WorkingGraph(theObject,
|
g_OperationParameters,
|
creatorHelper.LayerOrGroupObject,
|
theCallback);
|
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(createdGroupOrLayer);
|
}
|
}
|
break;
|
default:
|
//
|
// Do Nothing
|
//
|
}
|
}
|
//
|
// Get the next one in line...
|
//
|
childID = SGWorld.ProjectTree.GetNextItem(childID, ItemCode.NEXT);
|
}
|
if (polyFlag)
|
return true;
|
else return false
|
}
|
|
function WorkOnALayerOfShapes(theLayer) {
|
var createdGroupOrLayer = null;
|
var wallGroupOrLayer = null;
|
var fenceGroupOrLayer = null;
|
var theCallback = null;
|
var thefinalizationCallback = null;
|
|
g_OperationParameters.PostReference = null;
|
|
g_KeepAskingIfTooManyPoints = true;
|
var creatorHelper = new ClassCreateLayerOrGroupInfo();
|
creatorHelper.Create();
|
theCallback = creatorHelper.CreateItemCallback;
|
thefinalizationCallback = creatorHelper.FinalizationCallback;
|
|
if (g_OperationParameters.ObjectType == TYPE_WALLWITHFENCE)
|
{
|
if (g_OperationParameters.CreateAs == CREATEAS.Group)
|
{
|
//wall and fence can go in the same group
|
wallGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
fenceGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
}
|
else
|
{
|
//wall and fence can't go in the same layer because
|
//of the issue with creating multiple feature groups
|
//in a TE-created feature layer
|
wallGroupOrLayer = creatorHelper.LayerOrGroupObject[0];
|
fenceGroupOrLayer = creatorHelper.LayerOrGroupObject[1];
|
}
|
}
|
else
|
{
|
createdGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
}
|
|
var featureGroupsCount = theLayer.FeatureGroups.Count;
|
//
|
// A layer might contain different feature groups
|
//
|
for (var i = 0; i < featureGroupsCount; i++) {
|
var groupType = theLayer.FeatureGroups(i).GeometryType;
|
if (groupType != SGGeometryTypeId.SG_LINESTRING && groupType != SGGeometryTypeId.SG_LINEARRING)
|
continue;
|
|
var theFeatureGroup = theLayer.FeatureGroups(i);
|
for (j = 0; j < theFeatureGroup.Count; j++) {
|
var currentShape = theFeatureGroup(j);
|
|
if (g_OperationParameters.ObjectType == TYPE_WALLWITHFENCE)
|
{
|
var fenceHeight = parseFloat(g_OperationParameters.WallHeight) + parseFloat(g_OperationParameters.FenceHeight);
|
//call workinggraph twice, once for wall and once for fence
|
|
//wall
|
var fill;
|
switch(g_OperationParameters.WallFillStyle)
|
{
|
case FILLSTYLE.Color:
|
fill = g_OperationParameters.WallColor;
|
break;
|
case FILLSTYLE.Texture:
|
//texture will be default, since it's got to be one or the other
|
default:
|
fill = g_OperationParameters.WallTexture;
|
}
|
WorkingGraph(currentShape,
|
g_OperationParameters,
|
wallGroupOrLayer,
|
theCallback);
|
|
//fence
|
switch(g_OperationParameters.FenceFillStyle)
|
{
|
case FILLSTYLE.Color:
|
fill = g_OperationParameters.FenceColor;
|
break;
|
case FILLSTYLE.Texture:
|
//texture will be default, since it's got to be one or the other
|
default:
|
fill = g_OperationParameters.FenceTexture;
|
}
|
WorkingGraph(currentShape,
|
g_OperationParameters,
|
fenceGroupOrLayer,
|
theCallback);
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(wallGroupOrLayer);
|
thefinalizationCallback(fenceGroupOrLayer);
|
}
|
}
|
else
|
{
|
var fill;
|
switch(g_OperationParameters.FillStyle)
|
{
|
case FILLSTYLE.Color:
|
fill = g_OperationParameters.Color;
|
break;
|
case FILLSTYLE.Texture:
|
//texture will be default, since it's got to be one or the other
|
default:
|
fill = g_OperationParameters.Texture;
|
}
|
WorkingGraph(currentShape,
|
g_OperationParameters,
|
createdGroupOrLayer,
|
theCallback);
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(createdGroupOrLayer);
|
}
|
}
|
}
|
}
|
}
|
|
function WorkOnClipboardItems() {
|
|
var createdGroupOrLayer = null;
|
var theCallback = null;
|
var thefinalizationCallback = null;
|
var helperCreated = false;
|
var polyFlag = false;
|
|
g_OperationParameters.PostReference = null;
|
|
g_KeepAskingIfTooManyPoints = true;
|
var creatorHelper = new ClassCreateLayerOrGroupInfo();
|
|
|
// loop over the clipboard
|
for (var i = 0; i < SGWorld.Application.Clipboard.Count; i++) {
|
|
var theObject;
|
var objectType;
|
var objectTypeValid;
|
|
try {
|
theObject = SGWorld.Application.Clipboard.Item(i);
|
objectType = theObject.ObjectType;
|
objectTypeValid = true;
|
}
|
catch (err) {
|
objectTypeValid = false;
|
}
|
|
if (objectTypeValid) {
|
//If it is a layer set a layer callback
|
//If it is a group set a group callback
|
switch (objectType) { //1 = polyline, 2 = polygon
|
case ObjectTypeCode.OT_POLYLINE:
|
case ObjectTypeCode.OT_POLYGON:
|
polyFlag = true;
|
if (!helperCreated) {
|
//
|
// Calling Create() sets all necessary parameters.
|
//
|
creatorHelper.Create();
|
//
|
// Get the operation parameters.
|
//
|
createdGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
theCallback = creatorHelper.CreateItemCallback;
|
thefinalizationCallback = creatorHelper.FinalizationCallback;
|
|
helperCreated = true;
|
}
|
if (g_OperationParameters.ObjectType == TYPE_WALLWITHFENCE) {
|
var wallGroupOrLayer;
|
var fenceGroupOrLayer;
|
if (g_OperationParameters.CreateAs == CREATEAS.Group) {
|
//wall and fence can go in the same group
|
wallGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
fenceGroupOrLayer = creatorHelper.LayerOrGroupObject;
|
}
|
else {
|
//wall and fence can't go in the same layer because
|
//of the issue with creating multiple feature groups
|
//in a TE-created feature layer
|
wallGroupOrLayer = creatorHelper.LayerOrGroupObject[0];
|
fenceGroupOrLayer = creatorHelper.LayerOrGroupObject[1];
|
}
|
var fenceHeight = parseFloat(g_OperationParameters.WallHeight) + parseFloat(g_OperationParameters.FenceHeight);
|
//call workinggraph twice, once for wall and once for fence
|
|
//wall
|
WorkingGraph(theObject,
|
g_OperationParameters.WallParameters,
|
wallGroupOrLayer,
|
theCallback);
|
|
//fence
|
WorkingGraph(theObject,
|
g_OperationParameters.FenceParameters,
|
fenceGroupOrLayer,
|
theCallback);
|
|
if (thefinalizationCallback != null) {
|
thefinalizationCallback(wallGroupOrLayer);
|
thefinalizationCallback(fenceGroupOrLayer);
|
}
|
}
|
else {
|
WorkingGraph(theObject,
|
g_OperationParameters,
|
creatorHelper.LayerOrGroupObject,
|
theCallback);
|
if (thefinalizationCallback != null) {
|
// thefinalizationCallback(createdGroupOrLayer);
|
thefinalizationCallback(creatorHelper.LayerOrGroupObject);
|
}
|
}
|
break;
|
default:
|
//
|
// Do nothing
|
//
|
}
|
}
|
}
|
if (polyFlag)
|
return true;
|
else return false;
|
}
|
|
|
function SetCommonPropertiesForACreatedLayer(theCreatedLayer, params) {
|
var theFeaureGroup;
|
if (params.ObjectType == OBJECTTYPE.MeshFence || params.ObjectType == OBJECTTYPE.WireStrandFence) {
|
theFeaureGroup = theCreatedLayer.FeatureGroups.Polyline;
|
}
|
else if (params.ObjectType == OBJECTTYPE.Wall) {
|
theFeaureGroup = theCreatedLayer.FeatureGroups.Polygon;
|
}
|
|
var textureScaleY = params.Height;
|
//TODO: Until TE API is fixed to allow creation of multiple feature groups
|
//within a TE-created feature layer, creating a wall-and-fence type object
|
//requires multiple feature layers, so the fence and wall layers will each
|
//call this separately (hence why only fence and wall types are handled here)
|
|
theCreatedLayer.IgnoreZ = true;
|
|
|
theFeaureGroup.SetProperty("Altitude", params.Height);
|
theFeaureGroup.SetProperty("Max. Visibility Distance", params.VisibilityDistance);
|
//theFeaureGroup.SetProperty("Altitude Method", AltitudeTypeCode.ATC_TERRAIN_RELATIVE);
|
theFeaureGroup.SetProperty("Altitude Method", 1);
|
theFeaureGroup.SetProperty("Line Opacity", 0);
|
if (params.FillStyle == FILLSTYLE.Texture)
|
{
|
theFeaureGroup.SetProperty("Fill Opacity", 100);
|
theFeaureGroup.SetProperty("Texture File", params.Texture);
|
theFeaureGroup.SetProperty("Tiling Method", TilingMethodCode.TM_METERS_PER_TILE);
|
theFeaureGroup.SetProperty("Scale X", 1.5);
|
theFeaureGroup.SetProperty("Scale Y", textureScaleY);
|
}
|
else if (params.FillStyle == FILLSTYLE.Color)
|
{
|
var color = SGWorld.Creator.CreateColor(0,0,0,0);
|
color.FromHTMLColor(params.Color);
|
theFeaureGroup.SetProperty("Fill Opacity", params.Opacity);
|
theFeaureGroup.SetProperty("Fill Color", color.ToBGRColor());
|
}
|
theFeaureGroup.SetProperty("Extend to Ground", true);
|
theFeaureGroup.SetProperty("Ground Object", true);
|
if (params.ObjectType == OBJECTTYPE.Wall) theFeaureGroup.SetProperty("Ground Object", 0);
|
}
|
//
|
//
|
//
|
function GetCreatedGroupName(){
|
var baseName;
|
var i = 1;
|
switch (g_OperationParameters.ObjectType) {
|
case TYPE_WALL:
|
baseName = "Wall Group";
|
break;
|
case TYPE_FENCE:
|
baseName = "Mesh Fence Group";
|
break;
|
case TYPE_WALLWITHFENCE:
|
baseName = "Wall And Fence Group";
|
break;
|
case OBJECTTYPE.WireStrandFence:
|
baseName = "Wire Strand Fence Group";
|
break;
|
default:
|
throw new Error(2000, "Unable to create a unique group name - base object type is unrecognized");
|
}
|
while (SGWorld.ProjectTree.FindItem(baseName + " " + i) != 0)
|
{
|
i++;
|
}
|
return baseName + " " + i;
|
}
|
//
|
//
|
//
|
function GetCreatedLayerName() {
|
var baseName;
|
var i = 1;
|
switch (g_OperationParameters.ObjectType) {
|
case TYPE_WALL:
|
baseName = "Wall Layer";
|
break;
|
case TYPE_FENCE:
|
baseName = "Mesh Fence Layer";
|
break;
|
case TYPE_WALLWITHFENCE:
|
baseName = "Wall And Fence Layer";
|
break;
|
case OBJECTTYPE.WireStrandFence:
|
baseName = "Wire Strand Fence Layer";
|
break;
|
default:
|
throw new Error(2000, "Unable to create a unique group name - base object type is unrecognized");
|
}
|
if (g_OperationParameters.ObjectType != TYPE_WALLWITHFENCE)
|
{
|
while (SGWorld.ProjectTree.FindItem(baseName + " " + i) != 0)
|
{
|
i++;
|
}
|
}
|
//TODO: Until TE API is fixed to allow creation of multiple feature groups
|
//within a TE-created feature layer, creating a wall-and-fence type object
|
//requires multiple feature layers; until then layers are appended with
|
//" (Wall)" or " (Fence)" according to the layer they represent in the object
|
else
|
{
|
while (SGWorld.ProjectTree.FindItem(baseName + " " + i + " (Wall)") != 0 ||
|
SGWorld.ProjectTree.FindItem(baseName + " " + i + " (Fence)") != 0)
|
{
|
i++;
|
}
|
}
|
return baseName + " " + i;
|
}
|
//
|
//
|
//
|
function callbackEndOfGraphForLayer(theContainer) {
|
/*alert("in callbackEndOfGraphForLayer" + '\n' +
|
"layer name: " + theContainer.TreeItem.Name);*/
|
theContainer.Save();
|
theContainer.Refresh();
|
}
|
|
function callbackAddItemToLayer(theContainer, linesGeometry, altitude) {
|
/*alert("in callbackAddItemToLayer" + '\n' +
|
"layer name: " + theContainer.TreeItem.Name + '\n' +
|
"altitude: " + altitude);*/
|
var theStringObjectID;
|
if (linesGeometry.GeometryType == SGGeometryTypeId.SG_LINESTRING || linesGeometry.GeometryType == SGGeometryTypeId.SG_MULTILINESTRING) {
|
theStringObjectID = theContainer.FeatureGroups.Polyline.CreateFeature(linesGeometry);
|
}
|
else if (linesGeometry.GeometryType == SGGeometryTypeId.SG_POLYGON || linesGeometry.GeometryType == SGGeometryTypeId.SG_MULTIPOLYGON) {
|
//
|
// This occurs as a result of calling the buffer that creates a polygon
|
//
|
theStringObjectID = theContainer.FeatureGroups.Polygon.CreateFeature(linesGeometry);
|
}
|
else {
|
throw new Error(2000, "Expecting a line or multiline or a polygon");
|
}
|
|
var theObject = SGWorld.Creator.GetObject(theStringObjectID);
|
//SGWorld.Creator.DeleteObject(theStringObjectID);
|
return theObject;
|
}
|
//
|
//
|
//
|
function callbackAddItemToGroup(theContainer, linesGeometry, altitude){
|
|
//
|
// Create a terrain object
|
//
|
var theReturnObject = null;
|
|
if (linesGeometry.GeometryType == SGGeometryTypeId.SG_LINESTRING || linesGeometry.GeometryType == SGGeometryTypeId.SG_MULTILINESTRING) {
|
var theNewTerrainPolyline = SGWorld.Creator.CreatePolyline(linesGeometry, 0xFFB3FF44,
|
AltitudeTypeCode.ATC_TERRAIN_RELATIVE,
|
theContainer /* the group ID*/);
|
theReturnObject = theNewTerrainPolyline
|
theReturnObject.Position.Altitude = altitude;
|
|
theReturnObject.Position.AltitudeType = 3;
|
theReturnObject.Geometry.StartEdit();
|
if (linesGeometry.GeometryType == SGGeometryTypeId.SG_LINESTRING) {
|
for (var i = 0; i < theReturnObject.Geometry.NumPoints; i++) {
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theReturnObject.Geometry.Points(i).X, theReturnObject.Geometry.Points(i).Y, 2, true);
|
theReturnObject.Geometry.Points(i).Z = wpi.Position.Altitude + altitude;
|
}
|
}
|
else{
|
for (var i = 0; i < theReturnObject.Geometry.NumGeometries; i++) {
|
for (var j = 0; j < theReturnObject.Geometry(i).NumPoints; j++) {
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theReturnObject.Geometry(i).Points(j).X, theReturnObject.Geometry(i).Points(j).Y, 2, true);
|
theReturnObject.Geometry(i).Points(j).Z = wpi.Position.Altitude + altitude;
|
}
|
}
|
}
|
|
theReturnObject.Geometry.EndEdit();
|
}
|
|
else if (linesGeometry.GeometryType == SGGeometryTypeId.SG_POLYGON || linesGeometry.GeometryType == SGGeometryTypeId.SG_MULTIPOLYGON) {
|
|
//
|
// This occurs as a result of calling the buffer that creates a polygon
|
//
|
var theNewTerrainPolygon = SGWorld.Creator.CreatePolygon(linesGeometry, 0xFFB3FF44, 0xFFB3FF44,
|
AltitudeTypeCode.ATC_TERRAIN_ABSOLUTE,
|
theContainer /* the group ID*/);
|
theReturnObject = theNewTerrainPolygon;
|
|
theReturnObject.Position.AltitudeType = 3;
|
theReturnObject.Geometry.StartEdit();
|
for (var i = 0; i < theReturnObject.Geometry.NumPoints; i++) {
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theReturnObject.Geometry.Points(i).X, theReturnObject.Geometry.Points(i).Y, 2, true);
|
theReturnObject.Geometry.Points(i).Z = wpi.Position.Altitude + altitude;
|
}
|
theReturnObject.Geometry.EndEdit();
|
}
|
else {
|
throw new Error(2000, "Expecting a line or multiline or a polygon");
|
}
|
//
|
// Set common properties
|
//
|
if (g_OperationParameters.ObjectType != OBJECTTYPE.WallWithFence)
|
{
|
theReturnObject.Visibility.MaxVisibilityDistance = g_OperationParameters.VisibilityDistance;
|
}
|
else
|
{
|
theReturnObject.Visibility.MaxVisibilityDistance = g_OperationParameters.WallParameters.VisibilityDistance;
|
}
|
|
return theReturnObject;
|
}
|
//
|
//---------------------------
|
//
|
//
|
function VertexPointInfo() {
|
this.Vertex = null;
|
this.PointVertex = null;
|
this.Heading1 = 0;
|
this.Heading2 = 0;
|
this.HeadingToVertex = 0;
|
this.IsPointVertex = function(point) {
|
if (this.Vertex != null) {
|
var diff = this.Vertex.AimTo(point).Yaw - this.HeadingToVertex;
|
//alert("headingToPoint = " + this.Vertex.AimTo(point).Yaw + "\r\nheadingToVertex = " + this.HeadingToVertex + "\r\ndiff = " + diff);
|
if (diff > 359) {
|
diff -= 360;
|
}
|
else if (diff < -359) {
|
diff += 360;
|
}
|
return Math.abs(diff) < 0.05;
|
}
|
else return false;
|
}
|
}
|
//
|
//---------------------------
|
//
|
//
|
function FindEndCap(points, endCap, radius) {
|
var total = points.Count;
|
//alert("total = " + total);
|
for (var i = 0; i < total; i++) {
|
var point = points(i);
|
if (SGWorld.CoordServices.GetDistance(point.X, point.Y, endCap.X, endCap.Y) <= (radius + 0.1)) {
|
//alert("endcap starts at " + i);
|
return i;
|
}
|
}
|
}
|
//
|
//---------------------------
|
// WorkingGraph : The main working function that creates fences and walls.
|
|
function WorkingGraph(theShape, parameters, createdGroupOrLayer, callbackAddItemToGroupOrLayer) {
|
//
|
// Transform to Geos LineString or MultiLineString
|
//
|
var theLines = MakeLinesFromShape(theShape);
|
//
|
// Insert the additional weigh points.
|
//
|
|
var newGeometry;
|
//
|
// If it passes the quota of weighppoints an exception is thrown.
|
//
|
try {
|
|
/// 'if' is made to cover smaller fence sampling than posts sampling
|
|
if (parameters.PostSpacing > parameters.Sampling && parameters.PostSpacing % parameters.Sampling != 0) {
|
|
newGeometry = CreateExtraPointsToGeosLineString(theLines, parameters.PostSpacing, parameters.Height, parameters.SimplifyLine);
|
newGeometry = CreateExtraPointsToGeosLineString(newGeometry, parameters.Sampling, parameters.Height, parameters.SimplifyLine);
|
}
|
else newGeometry = CreateExtraPointsToGeosLineString(theLines, parameters.Sampling, parameters.Height, parameters.SimplifyLine);
|
|
|
// RPK: this is where the logic has to be for simplifying... or in the function above but with conditionals... see if it can be put here
|
// or right after the catch...
|
}
|
catch (e) {
|
//TODO: remove the created group or layer
|
return;
|
}
|
|
//
|
// Create a terrain object from GEOS LineString.
|
//
|
if (parameters.ObjectType == OBJECTTYPE.Wall) {
|
|
var bufferedShape = CreateABufferForTheShape(newGeometry, parameters.Width, parameters.Height)
|
//
|
// Delete the original shape??
|
//
|
newGeometry = bufferedShape;
|
}
|
|
//
|
// Call the callback function, the callback is responsible to set
|
// all common properties like altitude etc.
|
//
|
|
if (parameters.ObjectType != OBJECTTYPE.WireStrandFence) {
|
|
var theNewShape = callbackAddItemToGroupOrLayer(createdGroupOrLayer, newGeometry, parameters.Height);
|
|
createdGroupOrLayer.IgnoreZ = false;
|
|
if (theNewShape.ObjectType == 33) {
|
|
switch (theNewShape.Geometry.GeometryType) {
|
case 1: // SG_LINESTRING
|
{
|
groupParent = SGWorld.ProjectTree.GetLayer(theNewShape.ParentGroupID); // to overcome a bug: if an object is underground, wpi returns a wrong altitude.
|
groupParent.FeatureGroups.Polyline.SetProperty("Ground Object", 0);
|
|
theNewShape.Geometry.StartEdit();
|
for (var i = 0; i < theNewShape.Geometry.NumPoints; i++) {
|
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theNewShape.Geometry.Points(i).X, theNewShape.Geometry.Points(i).Y, 1, true);
|
//if ($("#ddlObjectType").val() == "Option_WallWithFence" && theNewShape.Geometry.GeometryType != 6) theNewShape.Geometry.Points(i).Z = wpi.Position.Altitude + parameters.Height + parseFloat($("#txtWallHeight").val());
|
if ($("#ddlObjectType").val() == "Option_WallWithFence" && theNewShape.Geometry.GeometryType != 6) theNewShape.Geometry.Points(i).Z = wpi.Position.Altitude + parameters.Height;
|
else theNewShape.Geometry.Points(i).Z = wpi.Position.Altitude + parameters.Height;
|
|
}
|
theNewShape.Geometry = theNewShape.Geometry.EndEdit();
|
groupParent.FeatureGroups.Polyline.SetProperty("Ground Object", 1);
|
}
|
//break;
|
|
case 5: //SG_MULTILINESTRING
|
{
|
groupParent = SGWorld.ProjectTree.GetLayer(theNewShape.ParentGroupID); // to overcome a bug: if an object is underground, wpi returns a wrong altitude.
|
groupParent.FeatureGroups.Polyline.SetProperty("Ground Object", 0);
|
|
theNewShape.Geometry.StartEdit();
|
for (var j = 0; j < theNewShape.Geometry.NumGeometries; j++) {
|
|
for (var i = 0; i < theNewShape.Geometry(j).NumPoints; i++) {
|
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theNewShape.Geometry(j).Points(i).X, theNewShape.Geometry(j).Points(i).Y, 1, true);
|
|
theNewShape.Geometry(j).Points(i).Z = wpi.Position.Altitude + parameters.Height;
|
// if ($("#ddlObjectType").val() == "Option_WallWithFence" && theNewShape.Geometry.GeometryType != 6) theNewShape.Geometry(j).Points(i).Z = wpi.Position.Altitude + parameters.Height + parseFloat($("#txtWallHeight").val());
|
// else theNewShape.Geometry(j).Points(i).Z = wpi.Position.Altitude + parameters.Height;
|
|
|
}
|
}
|
theNewShape.Geometry = theNewShape.Geometry.EndEdit();
|
groupParent.FeatureGroups.Polyline.SetProperty("Ground Object", 1);
|
}
|
break;
|
|
case 6: //SG_MULTIPOLYGON ei
|
{
|
theNewShape.Geometry.StartEdit();
|
for (var j = 0; j < theNewShape.Geometry.NumGeometries; j++) {
|
|
for (var i = 0; i < theNewShape.Geometry(j).ExteriorRing.NumPoints; i++) {
|
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theNewShape.Geometry(j).ExteriorRing.Points(i).X, theNewShape.Geometry(j).ExteriorRing.Points(i).Y, 1, true);
|
theNewShape.Geometry(j).ExteriorRing.Points(i).Z = wpi.Position.Altitude + parameters.Height
|
}
|
}
|
theNewShape.Geometry = theNewShape.Geometry.EndEdit();
|
|
}
|
break;
|
|
}
|
|
}
|
|
if (theNewShape.ObjectType != 33) theNewShape.Visibility.Show = false; //made to hide fence shapefile in order to get the correct post altitude from GetGroundHeightInfo
|
else createdGroupOrLayer.Visibility.Show = false;
|
|
DoExtendToGround(theNewShape, parameters);
|
|
}
|
else
|
{
|
//WIRE STRAND FENCE
|
var increments = parameters.Height / (parameters.NumberOfStrands + 1);
|
if (parameters.CreateAs != CREATEAS.Group)//its a layer
|
{
|
if (!createdGroupOrLayer.DataSourceInfo.Attributes.IsAttributeExist("Altitude"))
|
createdGroupOrLayer.DataSourceInfo.Attributes.CreateAttribute("Altitude",2,15,3); // 2=Double, 15=szChar,3=precision(num dec places)
|
var color = SGWorld.Creator.CreateColor(0,0,0,255);
|
color.FromHTMLColor(parameters.Color);
|
createdGroupOrLayer.FeatureGroups.Polyline.SetProperty("Extend to Ground", false);
|
createdGroupOrLayer.FeatureGroups.Polyline.SetProperty("Line Color", color);
|
createdGroupOrLayer.FeatureGroups.Polyline.SetProperty("Altitude", "[Altitude]");
|
createdGroupOrLayer.FeatureGroups.Polyline.SetProperty("Line Opacity", parameters.Opacity / 100);
|
createdGroupOrLayer.IgnoreZ = false;
|
createdGroupOrLayer.Visibility.Show = false; //made to hide fence shapefile in order to get the correct pole altitude from GetGroundHeightInfo
|
|
}
|
|
for (var i=0; i<parameters.NumberOfStrands; i++) {
|
|
var strandHeight = parameters.Height - ((i + 1) * increments);
|
var theNewShape = callbackAddItemToGroupOrLayer(createdGroupOrLayer, newGeometry, strandHeight);
|
|
if (parameters.CreateAs == CREATEAS.Group)
|
{
|
theNewShape.LineStyle.Color.FromHTMLColor(parameters.Color);
|
theNewShape.LineStyle.Color.SetAlpha(parameters.Opacity/100);
|
}
|
else
|
{
|
//it's a layer
|
theNewShape.FeatureAttributes(0).Value = strandHeight;
|
switch (theNewShape.Geometry.GeometryType) {
|
case 5:
|
{
|
theNewShape.Geometry.StartEdit();
|
for (var j = 0; j < theNewShape.Geometry.NumGeometries; j++) {
|
for (var k = 0; k < theNewShape.Geometry(j).NumPoints; k++) {
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theNewShape.Geometry(j).Points(k).X, theNewShape.Geometry(j).Points(k).Y, 1, true);
|
theNewShape.Geometry(j).Points(k).Z = wpi.Position.Altitude + strandHeight;
|
}
|
}
|
theNewShape.Geometry = theNewShape.Geometry.EndEdit();
|
}
|
break;
|
case 1:
|
{
|
theNewShape.Geometry.StartEdit();
|
for (var j = 0; j < theNewShape.Geometry.NumPoints; j++) {
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theNewShape.Geometry.Points(j).X, theNewShape.Geometry.Points(j).Y, 1, true);
|
theNewShape.Geometry.Points(j).Z = wpi.Position.Altitude + strandHeight;
|
}
|
theNewShape.Geometry = theNewShape.Geometry.EndEdit();
|
}
|
break;
|
}
|
}
|
}
|
}
|
|
/////////////////
|
//Posts
|
/////////////////
|
|
if (parameters.PostStyle != POSTSTYLE.None)
|
{
|
//make a geometry for the fence posts
|
newGeometry = CreateExtraPointsToGeosLineString(theLines, parameters.PostSpacing, 0);
|
|
//TODO: fill color and texture for posts
|
var lineColor = SGWorld.Creator.CreateColor(0,0,0,0);
|
var fillColor = SGWorld.Creator.CreateColor(0,0,0,255);
|
//Note that setting line color is hopefully a temporary solution to an issue
|
//of the post objects ignoring 0 alpha for some reason and still getting set to 100%
|
lineColor.FromHTMLColor(parameters.PostColor);
|
fillColor.FromHTMLColor(parameters.PostColor);
|
var countPoly = 1;
|
if (newGeometry.GeometryType == SGGeometryTypeId.SG_MULTILINESTRING)
|
{
|
countPoly = newGeometry.Count;
|
if (countPoly == 1)
|
newGeometry = newGeometry(0);
|
}
|
if (parameters.CreateAs == CREATEAS.Group)
|
{
|
for (var counterPoly = 0; counterPoly < countPoly; counterPoly++)
|
{
|
var subGeometry = newGeometry;
|
if (countPoly > 1)
|
{
|
subGeometry = newGeometry(counterPoly);
|
}
|
for (var i=0; i < subGeometry.Points.Count; i++) {
|
|
var wpi = SGWorld.Terrain.GetGroundHeightInfo(subGeometry.Points(i).X, subGeometry.Points(i).Y, 2, true);
|
var pos = SGWorld.Creator.CreatePosition(subGeometry.Points.Item(i).X, subGeometry.Points.Item(i).Y, wpi.Position.Altitude, AltitudeTypeCode.ATC_TERRAIN_ABSOLUTE, 0, 0, 0, 0);
|
var groupId = createdGroupOrLayer;
|
var description = "Post " + (i + 1);
|
//create a post object
|
var theShape;
|
if (parameters.PostStyle == POSTSTYLE.Circular)
|
{
|
theShape = SGWorld.Creator.CreateCylinder(pos, parameters.PostDiameter / 2, parameters.Height + parameters.PostExtension, lineColor, fillColor, -1/*number of segments*/, groupId, description);
|
}
|
else if (parameters.PostStyle == POSTSTYLE.Square)
|
{
|
theShape = SGWorld.Creator.CreateBox(pos, parameters.PostDiameter, parameters.PostDiameter, parameters.Height + parameters.PostExtension, lineColor, fillColor, groupId, description);
|
}
|
|
if (parameters.PostStyle == FILLSTYLE.Texture) {
|
theShape.FillStyle.Color.SetAlpha(1.0);
|
theShape.LineStyle.Color.SetAlpha(0.0);
|
theShape.FillStyle.Texture.FileName = parameters.PostTexture;
|
theShape.FillStyle.Texture.TilingMethod = TilingMethodCode.TM_METERS_PER_TILE;
|
theShape.FillStyle.Texture.ScaleX = 1;
|
theShape.FillStyle.Texture.ScaleY = parameters.Height + parameters.PostExtension;
|
}
|
}
|
//theNewShape.Visibility.Show = true;
|
}
|
}
|
else if (parameters.CreateAs == CREATEAS.Layer_Entire || parameters.CreateAs == CREATEAS.Layer_Streaming) {
|
|
var baseName = createdGroupOrLayer.TreeItem.Name;
|
//create a new layer for the posts
|
if (parameters.PostReference == null)
|
{
|
parameters.PostReference = CreateAShapeLayer(baseName + " Posts", parameters.CreateAs, "POSTS");
|
}
|
var layer = parameters.PostReference;
|
switch (parameters.PostStyle)
|
{
|
case POSTSTYLE.Circular:
|
layer.FeatureGroups.Point.DisplayAs = ObjectTypeCode.OT_CYLINDER;
|
layer.FeatureGroups.Point.SetProperty("Radius X", parameters.PostDiameter/2);
|
break;
|
case POSTSTYLE.Square:
|
layer.FeatureGroups.Point.DisplayAs = ObjectTypeCode.OT_BOX;
|
layer.FeatureGroups.Point.SetProperty("Length", parameters.PostDiameter);
|
layer.FeatureGroups.Point.SetProperty("Width", parameters.PostDiameter);
|
break;
|
default:
|
//TODO: error
|
}
|
|
|
layer.FeatureGroups.Point.SetProperty("Height", parameters.Height + parameters.PostExtension);
|
//if ($("#ddlObjectType").val() == "Option_WallWithFence" || theNewShape.Geometry.GeometryType != 6) layer.FeatureGroups.Point.SetProperty("Height", parseFloat($("#txtFenceHeight").val()) + parseFloat($("#txtFencePostExtension").val()));
|
if (parameters.PostFillStyle == FILLSTYLE.Color)
|
{
|
layer.FeatureGroups.Point.SetProperty("Line Color", lineColor.ToBGRColor());
|
layer.FeatureGroups.Point.SetProperty("Line Opacity", 0);
|
layer.FeatureGroups.Point.SetProperty("Fill Color", fillColor.ToBGRColor());
|
layer.FeatureGroups.Point.SetProperty("Fill Opacity", 100);
|
}
|
else
|
{
|
layer.FeatureGroups.Point.SetProperty("Line Opacity", 0);
|
layer.FeatureGroups.Point.SetProperty("Fill Opacity", 100);
|
layer.FeatureGroups.Point.SetProperty("Texture File", parameters.PostTexture);
|
layer.FeatureGroups.Point.SetProperty("Tiling Method", 1 /*TilingMethodCode.TM_METERS_PER_TILE*/);
|
layer.FeatureGroups.Point.SetProperty("Scale Y", parameters.Height + parameters.PostExtension);
|
}
|
|
layer.FeatureGroups.SetProperty("Altitude Method", 1);
|
//add points from the geometry as features
|
for (var counterPoly = 0; counterPoly < countPoly; counterPoly++) {
|
|
|
var subGeometry = newGeometry;
|
|
if (countPoly > 1)
|
{
|
subGeometry = newGeometry(counterPoly);
|
}
|
|
for (var i=0; i < subGeometry.Points.Count; i++)
|
{
|
theFeature = layer.FeatureGroups.Point.CreateFeature(subGeometry.Points.Item(i), "");
|
theFeature = SGWorld.ProjectTree.Getobject(theFeature);
|
wpi = SGWorld.Terrain.GetGroundHeightInfo(theFeature.Geometry.X, theFeature.Geometry.Y, 2, true);
|
theFeature.Geometry.Z = wpi.Position.Altitude;
|
|
|
|
|
}
|
}
|
callbackEndOfGraphForLayer(layer);
|
}
|
}
|
if (theNewShape.ObjectType != 33) theNewShape.Visibility.Show = true; //Show layer after have been hidden in order to get the correct pole altitude from GetGroundHeightInfo
|
else createdGroupOrLayer.Visibility.Show = true;
|
|
}
|
//
|
//------------------------------------
|
// MaxAltitude: Returns the higher altitude when comparing two points with a relative altitude
|
//
|
function MaxAltitude(point1, point2, altitude) {
|
// create positions relative to terrain
|
var pos1 = SGWorld.Creator.CreatePosition(point1.X, point1.Y, altitude, 0);
|
var pos2 = SGWorld.Creator.CreatePosition(point2.X, point2.Y, altitude, 0);
|
// switch to absolute
|
pos1 = pos1.ToAbsolute(0);
|
pos2 = pos2.ToAbsolute(0);
|
//alert("pos1.X = " + pos1.X + "\r\npos2.X = " + pos2.X + "\r\npos1.Y = " + pos1.Y + "\r\npos2.Y = " + pos2.Y + "\r\npos1.Alt = " + pos1.Altitude + "\r\npos2.Alt = " + pos2.Altitude);
|
// compare heights and return higher altitude
|
if (pos2.Altitude > pos1.Altitude) {
|
return pos2.Altitude;
|
}
|
else {
|
return pos1.Altitude;
|
}
|
}
|
//
|
//------------------------------------
|
// HeadingChange: Returns true if the heading changes more than g_MaxHeadingDiff
|
// assumes points are IPoint, not IPosition
|
//
|
function HeadingChange(point1, point2, point3, returnValueInsteadOfBool) {
|
// create new positions on terrain
|
var pos1 = SGWorld.Creator.CreatePosition(point1.X, point1.Y);
|
var pos2 = SGWorld.Creator.CreatePosition(point2.X, point2.Y);
|
var pos3 = SGWorld.Creator.CreatePosition(point3.X, point3.Y);
|
var heading1 = pos1.AimTo(pos2).Yaw;
|
var heading2 = pos2.AimTo(pos3).Yaw;
|
//alert("heading1 = " + heading1 + "\r\nheading2 = " + heading2);
|
var diff = Math.abs(heading2 - heading1);
|
if (diff > 180) {
|
//alert("wrapping around");
|
if (heading1 > heading2) {
|
heading2 += 360;
|
}
|
else {
|
heading1 += 360;
|
}
|
diff = Math.abs(heading2 - heading1);
|
}
|
//alert("diff = " + diff);
|
if (returnValueInsteadOfBool != null && returnValueInsteadOfBool == true) {
|
return heading2 - heading1;
|
}
|
else {
|
return diff > g_MaxHeadingDiff;
|
}
|
}
|
//
|
//------------------------------------
|
// IsParallel: calculates heading for pointA1-pointA2 and pointB1-pointB2
|
// returns true if they are within g_MaxHeadingDiff of each other
|
//
|
function IsParallel(pointA1, pointA2, pointB1, pointB2) {
|
var posA1 = SGWorld.Creator.CreatePosition(pointA1.X, pointA1.Y);
|
var posA2 = SGWorld.Creator.CreatePosition(pointA2.X, pointA2.Y);
|
var posB1 = SGWorld.Creator.CreatePosition(pointB1.X, pointB1.Y);
|
var posB2 = SGWorld.Creator.CreatePosition(pointB2.X, pointB2.Y);
|
var headingA = posA1.AimTo(posA2).Yaw;
|
var headingB = posB1.AimTo(posB2).Yaw;
|
var diff = Math.abs(headingA - headingB);
|
if (diff > 180) {
|
if (headingA > headingB) {
|
headingB += 360;
|
}
|
else {
|
headingA += 360;
|
}
|
diff = Math.abs(headingA - headingB);
|
}
|
return diff < g_MaxHeadingDiff;
|
}
|
//
|
//------------------------------------
|
// CreateABufferForTheShape: Create a buffer for walls
|
//
|
function CreateABufferForTheShape(theGeometryToBuffer, desiredWallWidth, pointsAltitude)
|
{
|
//
|
// Reflect the buffer size according to final requested wall width
|
//
|
var bufferSize = desiredWallWidth / 2.0;
|
//
|
// Create the buffer
|
//
|
//var theBufferShape = theGeometryToBuffer.SpatialOperator.buffer(bufferSize);
|
|
// We do not want to create a buffer here using GEOS because of two reasons:
|
// 1. The generated polygon is difficult to Ofer to apply textures to, and it creates visual bugs becasue of points ordering
|
// 2. Later in code, this onterrain polygon is given altitude. But if the wall is defined on steep terrain, the top of wall becomes inclined which is not natural
|
// To fix both those problems we do the following
|
// 1. Split the line to segments by points.
|
// 2. Convert each segment defined by 2 points to rectangle of 4 points with absolute heights.
|
// 3. Connect each rectangle of wall with connector that hides the connections between rectangles
|
|
var polygons = [];
|
// geometry here can be either LineString or MultiLineString
|
if(theGeometryToBuffer.GeometryType == SGGeometryTypeId.SG_LINESTRING)
|
{
|
polygons = CreateABufferForSingleGeometry(theGeometryToBuffer, bufferSize, pointsAltitude);
|
}
|
else
|
{
|
for(var i=0;i<theGeometryToBuffer.Count;i++)
|
{
|
polygons.push.apply(polygons, CreateABufferForSingleGeometry(theGeometryToBuffer(i), bufferSize, pointsAltitude));
|
}
|
}
|
|
return SGWorld.Creator.GeometryCreator.CreateMultiPolygonGeometry(polygons);
|
}
|
|
function CreateABufferForSingleGeometry(theGeometryToBuffer, bufferSize, pointsAltitude)
|
{
|
// so first, get the list of points from theGeometryToBuffer to array in format [x,y,z,x,y,z....]
|
var points = GetPointsArray(theGeometryToBuffer);
|
|
// convert each point zValue to absolute height
|
for (var i = 0; i < points.length; i += 3)
|
{
|
var heightInfo = SGWorld.Terrain.GetGroundHeightInfo(points[i], points[i + 1], AccuracyLevel.ACCURACY_BEST_FROM_MPT);
|
heightInfo.Position.ChangeAltitudeType(AltitudeTypeCode.ATC_TERRAIN_ABSOLUTE);
|
points[i + 2] = heightInfo.Position.Altitude + pointsAltitude;
|
}
|
// create array of wall polygons based on points array
|
return CreateBufferedPolygonsArray(points, bufferSize);
|
}
|
|
function GetPointsArray(lineString)
|
{
|
return new VBArray(lineString.Points.ToArray()).toArray();
|
}
|
|
function IPositionFromArray(arr, i)
|
{
|
return SGWorld.Creator.CreatePosition(arr[i * 3], arr[i * 3 + 1], arr[i * 3 + 2], AltitudeTypeCode.ATC_TERRAIN_ABSOLUTE)
|
}
|
|
function CreateBufferedPolygonsArray(points, bufferSize)
|
{
|
var prevLinearRingPoints, prevPos;
|
var numberOfSegments = points.length / 3 - 1;
|
var bufferedPolygons = [];
|
for (var i = 0; i < numberOfSegments; i++)
|
{
|
var pos1 = IPositionFromArray(points, i);
|
var pos2 = IPositionFromArray(points, i + 1);
|
// lets build a wall segment (rectangle buffered by bufferSize around a line defined by pos1 and pos2) from point i to point i+1
|
var linearRingPoints = CreateBufferedRectangle(pos1,pos2,bufferSize);
|
// if there is prev linear ring, create a connector to it
|
if(prevLinearRingPoints)
|
{
|
var dx1 = prevPos.X - pos1.X;
|
var dy1 = prevPos.Y - pos1.Y;
|
var dx2 = pos2.X - pos1.X;
|
var dy2 = pos2.Y - pos1.Y;
|
var len1 = Math.sqrt(dx1 * dx1 + dy1*dy1);
|
var len2 = Math.sqrt(dx2 * dx2 + dy2*dy2);
|
var dot = (dx1 * dx2 + dy1 * dy2) / (len1 * len2);
|
// add connector only if the angle between two segments is big enough
|
if(Math.abs(dot) < 0.999)
|
{
|
var linearRing1 = SGWorld.Creator.GeometryCreator.CreateLinearRingGeometry([prevLinearRingPoints[2],linearRingPoints[0],prevLinearRingPoints[1], linearRingPoints[3], prevLinearRingPoints[2]]);
|
bufferedPolygons.push(SGWorld.Creator.GeometryCreator.CreatePolygonGeometry(linearRing1));
|
}
|
}
|
// add linearRing to our multiPolygon
|
var linearRing = SGWorld.Creator.GeometryCreator.CreateLinearRingGeometry(linearRingPoints);
|
bufferedPolygons.push(SGWorld.Creator.GeometryCreator.CreatePolygonGeometry(linearRing));
|
prevLinearRingPoints = linearRingPoints;
|
prevPos = pos1;
|
}
|
//if last and first points of the array are the same and there are more then 2 segments - it means this is closed polygon and we need to close the wall with connector
|
if (numberOfSegments > 2 && points[0] == points[points.length - 3] && points[1] == points[points.length - 2] && points[2] == points[points.length - 1])
|
{
|
var rect1 = CreateBufferedRectangle(IPositionFromArray(points, numberOfSegments - 1), IPositionFromArray(points, numberOfSegments), bufferSize);
|
var rect2 = CreateBufferedRectangle(IPositionFromArray(points, 0), IPositionFromArray(points, 1), bufferSize);
|
var linearRing1 = SGWorld.Creator.GeometryCreator.CreateLinearRingGeometry([rect1[2],rect2[0],rect1[1], rect2[3], rect1[2]]);
|
bufferedPolygons.push(SGWorld.Creator.GeometryCreator.CreatePolygonGeometry(linearRing1));
|
}
|
return bufferedPolygons;
|
}
|
|
function CreateBufferedRectangle(pos1, pos2, bufferSize)
|
{
|
var start = pos1.AimTo(pos2);
|
var end = pos2.AimTo(pos1);
|
var startLeft = start.Copy();
|
SGWorld.CoordServices.MoveCoordEx(startLeft, 0, bufferSize, 0);
|
var startRight = start.Copy();
|
SGWorld.CoordServices.MoveCoordEx(startRight, 0, -bufferSize, 0);
|
|
var endLeft = end.Copy();
|
SGWorld.CoordServices.MoveCoordEx(endLeft, 0, -bufferSize, 0);
|
var endRight = end.Copy();
|
SGWorld.CoordServices.MoveCoordEx(endRight, 0, bufferSize, 0);
|
return [startRight,endRight,endLeft, startLeft, startRight];
|
}
|
|
//
|
//------------------------------------
|
// DoExtendToGround: Do the actual streching and tiling to create the fence or the wall.
|
//
|
function DoExtendToGround(theShape, parameters) {
|
//
|
// If the shape is from a layer then it is an OT_FEATURE and not a terrain polygon
|
// or a terrain polyline.
|
//
|
var shapeIsInGroupAndNotInLayer = null;
|
var scaleX = 1.5;
|
var scaleY = parameters.Height;
|
|
if (ObjectTypeCode.OT_FEATURE == theShape.ObjectType) {
|
shapeIsInGroupAndNotInLayer = false;
|
} else {
|
shapeIsInGroupAndNotInLayer = true;
|
}
|
|
if (shapeIsInGroupAndNotInLayer) {
|
theShape.LineStyle.Color.SetAlpha(0);
|
if (parameters.FillStyle == FILLSTYLE.Color)
|
{
|
theShape.FillStyle.Texture.FileName = "";
|
theShape.FillStyle.Color.FromHTMLColor(parameters.Color);
|
theShape.FillStyle.Color.SetAlpha(parameters.Opacity/100);
|
}
|
else
|
{
|
theShape.FillStyle.Color.FromHTMLColor("000000");
|
theShape.FillStyle.Color.SetAlpha(1.0);
|
theShape.FillStyle.Texture.FileName = parameters.Texture;
|
theShape.FillStyle.Texture.TilingMethod = TilingMethodCode.TM_METERS_PER_TILE;
|
theShape.FillStyle.Texture.ScaleX = scaleX;
|
theShape.FillStyle.Texture.ScaleY = scaleY;
|
}
|
|
theShape.Terrain.GroundObject = false;
|
theShape.ExtendToGround = true;
|
}
|
//
|
// If the shape is in a layer then all the above steps have been handled during layer creation.
|
//
|
}
|
//
|
//
|
//
|
function MakeLinesFromShape(theShape) {
|
//
|
// The shape at this point is actually an OT_FEATURE if it comes from a layer and not from a group (33)
|
// Don't mix between the geometry type and the object type
|
//
|
switch (theShape.Geometry.GeometryType) {
|
case SGGeometryTypeId.SG_POLYGON:
|
case SGGeometryTypeId.SG_MULTIPOLYGON:
|
return MakeMultilineStringFromTerrainPolygon(theShape);
|
|
case SGGeometryTypeId.SG_LINESTRING:
|
case SGGeometryTypeId.SG_MULTILINESTRING:
|
return MakeMultilineStringFromTerrainPolyline(theShape);
|
//
|
//
|
//
|
default:
|
throw new Error(2000, "Unexpected shape type");
|
}
|
|
}
|
|
function MakeMultilineStringFromTerrainPolyline(theTerrainPolyline) {
|
if (theTerrainPolyline.Geometry.GeometryType == SGGeometryTypeId.SG_LINESTRING || theTerrainPolyline.Geometry.GeometryType == SGGeometryTypeId.SG_MULTILINESTRING) {
|
//LineString || //MultiLineString
|
|
return theTerrainPolyline.Geometry.Clone();
|
}
|
else {
|
throw new Error(2000, "Expecting a line or multiline");
|
}
|
}
|
|
|
//
|
// From terrain polygon (regular or multi) to a Geos MultilineString
|
//
|
function MakeMultilineStringFromTerrainPolygon(theTerrainPolygon) {
|
var theMultiLineString = null;
|
|
switch (theTerrainPolygon.Geometry.GeometryType) {
|
case SGGeometryTypeId.SG_POLYGON:
|
//alert("MakeMultilineStringFromTerrainPolygon working on polygon");
|
theMultiLineString = MakeMultilineStringFromIPolygon_WorkerFunc(theTerrainPolygon.Geometry, null);
|
break;
|
|
case SGGeometryTypeId.SG_MULTIPOLYGON:
|
//alert("MakeMultilineStringFromTerrainPolygon working on multipolygon");
|
for (var i = 0; i < theTerrainPolygon.Geometry.Count; i++) {
|
//
|
// At first time it will pass null, afterwards it will pass the expected
|
// existing object.
|
//
|
theMultiLineString = MakeMultilineStringFromIPolygon_WorkerFunc(theTerrainPolygon.Geometry(i), theMultiLineString);
|
}
|
break;
|
|
default:
|
throw new Error(2000, "Unexpected shape type");
|
}
|
|
|
return theMultiLineString;
|
|
}
|
|
function MakeMultilineStringFromIPolygon_WorkerFunc(theIPolygon, existingMultilineString) {
|
//alert("theIPolygon.Rings.Count = " + theIPolygon.Rings.Count);
|
var lineStringArray = new Array();
|
for (var ringIndex = 0; ringIndex < theIPolygon.Rings.Count; ringIndex++) {
|
//
|
// Loop for each ring
|
//
|
var verticesIndex = 0;
|
var verticesArray = new Array();
|
var currentRing = theIPolygon.Rings(ringIndex);
|
//alert("currentRing.Points.Count = " + currentRing.Points.Count);
|
for (var pointsIndex = 0; pointsIndex < currentRing.Points.Count; pointsIndex++) {
|
//
|
// Loop for each point in the ring
|
//
|
verticesArray[verticesIndex++] = currentRing.Points(pointsIndex).X;
|
verticesArray[verticesIndex++] = currentRing.Points(pointsIndex).Y;
|
verticesArray[verticesIndex++] = currentRing.Points(pointsIndex).Z;
|
}
|
//
|
// We should add the first polygon point as the last point of the polyline
|
//
|
verticesArray[verticesIndex++] = currentRing.Points(0).X;
|
verticesArray[verticesIndex++] = currentRing.Points(0).Y;
|
verticesArray[verticesIndex++] = currentRing.Points(0).Z;
|
//
|
// Now we are ready to create a LineString geometry.
|
//
|
lineStringArray[ringIndex] = SGWorld.Creator.GeometryCreator.CreateLineStringGeometry(verticesArray);
|
}
|
|
if (existingMultilineString == null) {
|
var theMultiLineString = SGWorld.Creator.GeometryCreator.CreateMultiLineStringGeometry(lineStringArray);
|
return theMultiLineString;
|
}
|
else {
|
//
|
// We already have an existing object
|
// Just add all the lineString that we have to that object.
|
existingMultilineString.StartEdit();
|
for (var i = 0; i < lineStringArray.length; i++) {
|
existingMultilineString.AddGeometry(lineStringArray[i]);
|
}
|
var newGeometry = existingMultilineString.EndEdit();
|
|
return newGeometry;
|
}
|
}
|
//
|
//
|
//
|
function CreateExtraPointsToGeosLineString(theLineString, spacingSizeMeters, pointsAltitude, simplifyLine) {
|
var geoType = theLineString.GeometryType;
|
var newGeometry;
|
var bPassedAllowedWaypoints;
|
|
g_NumWaypoints = 0;
|
|
if (geoType == SGGeometryTypeId.SG_LINESTRING) {
|
//
|
// LineString
|
//
|
theLineString.StartEdit();
|
//
|
//
|
//
|
bPassedAllowedWaypoints = CreateExtraPointsToLineString_WorkerFunc(theLineString, spacingSizeMeters, pointsAltitude, simplifyLine);
|
//
|
//
|
//
|
newGeometry = theLineString.EndEdit();
|
}
|
else if (geoType == SGGeometryTypeId.SG_MULTILINESTRING) {
|
//
|
// MultiLineString
|
//
|
theLineString.StartEdit();
|
//
|
//
|
//
|
for (var i = 0; i < theLineString.Count; i++) {
|
bPassedAllowedWaypoints = CreateExtraPointsToLineString_WorkerFunc(theLineString(i), spacingSizeMeters, pointsAltitude, simplifyLine);
|
}
|
//
|
//
|
//
|
newGeometry = theLineString.EndEdit();
|
}
|
else {
|
throw new Error(2000, "Unexpected type");
|
}
|
|
if (bPassedAllowedWaypoints) {
|
throw new Error(2001, "Too many waypoints");
|
}
|
return newGeometry;
|
}
|
//
|
// Expecting an ILineString interface.
|
//
|
function CreateExtraPointsToLineString_WorkerFunc(theLineString, spacing, pointsAltitude, simplifyLine) {
|
var geoType = theLineString.GeometryType;
|
var numLinePoints = theLineString.Points.Count;
|
var prevSlope = undefined;
|
//
|
// Create positions from first point and the last point
|
//
|
var workIndex = 0;
|
var totalDistanceAddedSoFar = 0;
|
var j = 0;
|
for (var i = 0; i < numLinePoints - 1; i++) {
|
var pointStart = theLineString.Points(workIndex);
|
pointStart.Z = pointsAltitude;
|
var pointEnd = theLineString.Points(workIndex + 1);
|
pointEnd.Z = pointsAltitude;
|
var positionStart = SGWorld.Creator.CreatePosition(pointStart.X, pointStart.Y, pointsAltitude, AltitudeTypeCode.ATC_TERRAIN_RELATIVE);
|
var positionEnd = SGWorld.Creator.CreatePosition(pointEnd.X, pointEnd.Y, pointsAltitude, AltitudeTypeCode.ATC_TERRAIN_RELATIVE);
|
|
var dist = SGWorld.CoordServices.GetDistance3D(positionStart, positionEnd);
|
|
totalDistanceAddedSoFar = 0.0;
|
j = 0;
|
//
|
// Stop the loop before we pass the second point.
|
// We insert points between 2 adjacent points.
|
//
|
var pos1 = positionStart;
|
var pos2 = null;
|
var pos3 = null;
|
|
var a1,a2;
|
|
var fullCount = 0;
|
// doAddPoint is used insanely. I apologize.
|
var doAddPoint = true;
|
while (totalDistanceAddedSoFar + spacing < dist) {
|
var newPosition = positionStart.MoveToward(positionEnd, spacing * (fullCount + 1));
|
// newPosition = newPosition.ToAbsolute(0 /*ACCURACY_NORMAL*/);
|
var checkSlope = false;
|
if (simplifyLine) {
|
if (!pos2) {
|
doAddPoint = false;
|
pos2 = newPosition;
|
}
|
else {
|
if (pos3) {
|
if (doAddPoint)
|
{
|
pos1 = pos2;
|
}
|
doAddPoint = true;
|
pos2 = pos3;
|
}
|
pos3 = newPosition;
|
checkSlope = true;
|
}
|
}
|
|
if (checkSlope && simplifyLine && doAddPoint) {
|
pos1 = pos1;
|
pos2 = pos2;
|
pos3 = pos3;
|
var npos1 = pos1.ToAbsolute(0);
|
var npos2 = pos2.ToAbsolute(0);
|
var npos3 = pos3.ToAbsolute(0);
|
//alert("Interrogate pos1: "+ pos1.X + " " + pos1.Y + " " + pos1.Altitude);
|
//alert("Interrogate pos2: "+ pos2.X + " " + pos2.Y + " " + pos2.Altitude);
|
//alert("Interrogate pos3: "+ pos3.X + " " + pos3.Y + " " + pos3.Altitude);
|
var slopeTo1 = (npos2.Altitude - npos1.Altitude) / SGWorld.CoordServices.GetDistance(npos1.X, npos1.Y, npos2.X, npos2.Y);
|
var slopeTo3 = (npos3.Altitude - npos2.Altitude) / SGWorld.CoordServices.GetDistance(npos2.X, npos2.Y, npos3.X, npos3.Y);
|
var diff = slopeTo1 - slopeTo3;
|
//alert("diff = " + diff);
|
if (Math.abs(diff) < g_MinSlopeDiff) {
|
//alert("removing point " + (workIndex + j) + "\r\nslope1 = " + slopeTo1 + "\r\nslope3 = " + slopeTo3);
|
doAddPoint = false;
|
}
|
}
|
|
if (doAddPoint) {
|
var addPoint;
|
if (simplifyLine) {
|
addPoint = pos2; //.ToRelative(0);
|
}
|
else {
|
addPoint = newPosition; //.ToRelative(0);
|
}
|
theLineString.Points.InsertPoint(workIndex + j, addPoint.X, addPoint.Y, pointsAltitude); //, addPoint.Altitude);//pointsAltitude);
|
//alert(addPoint.Altitude + " " + pointsAltitude);
|
j++;
|
}
|
if (g_KeepAskingIfTooManyPoints) {
|
if (doAddPoint)
|
g_NumWaypoints++;
|
if (g_NumWaypoints > g_OperationParameters.MaxWaypoints) {
|
//
|
// return true means that we have passed the quota
|
//
|
var doContinueWithNoAsking = confirm(SGLang.i18n("ERROR_TEXT_WaypointsPassedQuota"));
|
if (doContinueWithNoAsking) {
|
g_KeepAskingIfTooManyPoints = false;
|
}
|
else {
|
return true;
|
}
|
}
|
}
|
fullCount++;
|
totalDistanceAddedSoFar += spacing;
|
}
|
if (pos2 && pos3 && simplifyLine) {
|
pos1 = pos2;
|
pos2 = pos3;
|
var pos3 = positionEnd; // already absolute
|
|
var npos1 = pos1.ToAbsolute(0);
|
var npos2 = pos2.ToAbsolute(0);
|
var npos3 = pos3.ToAbsolute(0);
|
|
var slopeTo1 = (npos2.Altitude - npos1.Altitude) / SGWorld.CoordServices.GetDistance(npos1.X, npos1.Y, npos2.X, npos2.Y);
|
var slopeTo3 = (npos3.Altitude - npos2.Altitude) / SGWorld.CoordServices.GetDistance(npos2.X, npos2.Y, npos3.X, npos3.Y);
|
var diff = slopeTo1 - slopeTo3;
|
//alert("diff = " + diff);
|
if (Math.abs(diff) < g_MinSlopeDiff) {
|
//alert("removing point " + (workIndex + j) + "\r\nslope1 = " + slopeTo1 + "\r\nslope3 = " + slopeTo3);
|
}
|
else {
|
theLineString.Points.InsertPoint(workIndex + j, pos2.X, pos2.Y, pointsAltitude); //pos2.Altitude);//pointsAltitude);
|
//alert(pos2.Altitude + " " + pointsAltitude);
|
j++;
|
}
|
}
|
//alert(theLineString.Points.Count);
|
workIndex += j + 1;
|
}
|
|
//
|
// return false means that we have passed the quota
|
//
|
return false;
|
}
|
//
|
//
|
//
|
function CreateAShapeLayer(layerName, streamingType, objType) {
|
//
|
// If it is a fence we should create a polyline layer
|
// If it is a wall we should create a polygon layer since the result of buffer is a polygon.
|
//
|
|
var layerType;
|
if (objType == TYPE_FENCE || objType == OBJECTTYPE.WireStrandFence) {
|
layerType = LayerGeometryType.LGT_POLYLINE;
|
}
|
else if (objType == TYPE_WALL) {
|
layerType = LayerGeometryType.LGT_POLYGON;
|
}
|
else if (objType == "POSTS")
|
{
|
layerType = LayerGeometryType.LGT_POINT;
|
}
|
else {
|
throw new Error(2000, "Can't create a shape layer for this object type");
|
}
|
|
var filename = SanitizeLayerName(layerName);
|
var postfix = new Date().getTime();
|
|
//FileName= was previously set to a static string and was messing up the fence and wall layer... using objType for now as a distinguishing feature
|
var newLayer = SGWorld.Creator.CreateNewFeatureLayer(layerName, layerType, "TEPlugName=OGR;FileName=" + filename + postfix + ".shp");
|
|
newLayer.Streaming = streamingType == "LayerStreaming";
|
newLayer.Load();
|
|
return newLayer;
|
}
|
|
function SanitizeLayerName(layerName)
|
{
|
var sanitizedName = layerName;
|
//replace spaces, dashes (-), parentheses, and dots (.) with underscore (_)
|
sanitizedName = sanitizedName.replace(/[\s\-\.]/g, "_");
|
//eliminate other special characters
|
sanitizedName = sanitizedName.replace(/[^0-9A-Za-z_]/g, "");
|
|
//alert("sanitized" + '\n' + layerName + '\n' + "to" + '\n' + sanitizedName);
|
|
return sanitizedName;
|
}
|
