private MeshQuery.Result ModifyVertices(MeshQuery query, List <int> indecies)
{
var upMode = query.ForceDirection.y > 0;
var modified = 0;
var scannedTriangles = 0;
// modify vertices
for (int j = 0; j < indecies.Count; j++)
{
int outerIndex = indecies[j] * 3;
for (var k = 0; k < 3; k++)
{
var index = outerIndex + k;
var vertex = query.Vertices[index];
var distance = Vector3.Distance(vertex, query.Epicenter);
if (distance < query.Radius)
{
float heightDiff = query.GetForceChange(distance);
query.Vertices[index] = new Vector3(
vertex.x,
vertex.y + (upMode ? heightDiff : -heightDiff),
vertex.z);
modified++;
}
}
scannedTriangles++;
}
return(new MeshQuery.Result(query.Vertices)
{
ModifiedVertices = modified,
ScannedTriangles = scannedTriangles
});
}
/// <inheritdoc />
public MeshQuery.Result Modify(MeshQuery query)
{
var result = new List <int>(4);
var center = query.Epicenter;
var x = (int)Math.Floor((center.x - _left) / _xAxisStep);
var y = (int)Math.Floor((center.z - _bottom) / _yAxisStep);
var center2d = new Vector2d(center.x, center.z);
for (int j = y - 1; j <= y + 1; j++)
{
for (int i = x - 1; i <= x + 1; i++)
{
var rectangle = new Rectangle2d(
_bottomLeft.X + i * _xAxisStep,
_bottomLeft.Y + j * _yAxisStep,
_xAxisStep,
_yAxisStep);
// NOTE enlarge search radius to prevent some issues with adjusted triangles
// as their position in index defined by their centroid
// actually, additional size depends on terrain triangle area
if (GeometryUtils.HasCollision(center2d, query.Radius + 6, rectangle))
{
AddRange(i, j, result);
}
}
}
return(ModifyVertices(query, result));
}
public static void Modify(MeshQuery query)
{
Collider[] hitColliders = Physics.OverlapSphere(query.Epicenter, query.Radius);
foreach (var hitCollider in hitColliders)
{
var meshIndexBehavior = hitCollider.gameObject.GetComponent<MeshIndexBehaviour>();
if (meshIndexBehavior == null)
continue;
var mesh = hitCollider.gameObject.GetComponent<MeshFilter>().mesh;
query.Vertices = mesh.vertices;
var meshQueryResult = meshIndexBehavior.Index.Modify(query);
if (meshQueryResult.IsDestroyed)
{
var collider = hitCollider;
ObservableUnity
.FromCoroutine(() => SplitMesh(collider.gameObject))
.Subscribe();
}
else if (meshQueryResult.IsModified)
{
mesh.vertices = meshQueryResult.Vertices;
meshIndexBehavior.IsMeshModified = true;
}
Debug.Log(String.Format("MeshIndex:{0} modified:{1} scanned tris:{2}, forceDir:{3}",
hitCollider.name, meshQueryResult.ModifiedVertices, meshQueryResult.ScannedTriangles, query.ForceDirection));
}
}
/// <inheritdoc />
public MeshQuery.Result Modify(MeshQuery query)
{
return(new MeshQuery.Result(query.Vertices)
{
IsDestroyed = true
});
}
public void CanMakeQuery()
{
// ARRANGE
var vertices = GetVertices();
var query = new MeshQuery()
{
Epicenter = new Vector3(0, Radius, 0),
ForceDirection = new Vector3(0, -1, 0),
GetForceChange = f => 1,
Vertices = vertices,
Radius = Radius,
OffsetThreshold = 1
};
// ACT
var meshIndex = new SphereMeshIndex(Radius, Center);
meshIndex.Build();
var result = meshIndex.Modify(query);
// ASSERT
Assert.IsNotNull(result);
Assert.Greater(result.ModifiedVertices, 0);
Assert.Greater(result.DestroyedVertices, 0);
}
public static void Modify(MeshQuery query)
{
Collider[] hitColliders = Physics.OverlapSphere(query.Epicenter, query.Radius);
foreach (var hitCollider in hitColliders)
{
var meshIndexBehavior = hitCollider.gameObject.GetComponent <MeshIndexBehaviour>();
if (meshIndexBehavior == null)
{
continue;
}
var mesh = hitCollider.gameObject.GetComponent <MeshFilter>().mesh;
query.Vertices = mesh.vertices;
var meshQueryResult = meshIndexBehavior.Index.Modify(query);
if (meshQueryResult.IsDestroyed)
{
var collider = hitCollider;
ObservableUnity
.FromCoroutine(() => SplitMesh(collider.gameObject))
.Subscribe();
}
else if (meshQueryResult.IsModified)
{
mesh.vertices = meshQueryResult.Vertices;
meshIndexBehavior.IsMeshModified = true;
}
Debug.Log(String.Format("MeshIndex:{0} modified:{1} scanned tris:{2}, forceDir:{3}",
hitCollider.name, meshQueryResult.ModifiedVertices, meshQueryResult.ScannedTriangles, query.ForceDirection));
}
}
/// <summary> Modifies mesh plane based on it's equation parameters. </summary>
protected MeshQuery.Result Modify(MeshQuery query, int startIndex, int endIndex,
Vector3 n, float magnitude, float d)
{
var halfVertexCount = query.Vertices.Length / 2;
var vertices = query.Vertices;
int modified = 0;
var destroyed = 0;
for (int j = startIndex; j < endIndex; j += 3)
{
// triangle is already collapsed
if (vertices[j] == vertices[j + 1])
{
continue;
}
for (int i = j; i < j + 3; i++)
{
var v = vertices[i];
var distance = Vector3.Distance(v, query.Epicenter);
if (distance < query.Radius)
{
var distanceToWall = (v.x * n.x + v.y * n.y + v.z * n.z - d) / magnitude;
var forceChange = query.GetForceChange(distance);
// NOTE whole traingle should be removed as one of the vertices is
// moved more than threshold allows
if (Math.Abs(distanceToWall + forceChange) > query.OffsetThreshold)
{
// collapse triangle into point
var firstVertIndex = i - i % 3;
vertices[firstVertIndex + 1] = vertices[firstVertIndex];
vertices[firstVertIndex + 2] = vertices[firstVertIndex];
var backSideIndex = halfVertexCount + firstVertIndex;
vertices[backSideIndex + 1] = vertices[backSideIndex];
vertices[backSideIndex + 2] = vertices[backSideIndex];
destroyed += 3;
break;
}
vertices[i] = v + forceChange * query.ForceDirection;
vertices[halfVertexCount + i] = vertices[i];
modified++;
}
}
}
return(new MeshQuery.Result(query.Vertices)
{
DestroyedVertices = destroyed,
ModifiedVertices = modified,
ScannedTriangles = -1
});
}
/// <inheritdoc />
public MeshQuery.Result Modify(MeshQuery query)
{
var result = new MeshQuery.Result(query.Vertices);
foreach (var meshIndex in _indices)
{
var intermediateResult = meshIndex.Modify(query);
result.ModifiedVertices += intermediateResult.ModifiedVertices;
result.DestroyedVertices += intermediateResult.DestroyedVertices;
result.ScannedTriangles += intermediateResult.ScannedTriangles;
result.IsDestroyed |= intermediateResult.IsDestroyed;
}
return(result);
}
/// <inheritdoc />
public MeshQuery.Result Modify(MeshQuery query)
{
var vertices = query.Vertices;
int modified = 0;
var destroyed = 0;
for (int j = 0; j < vertices.Length; j += 3)
{
// triangle is already collapsed
if (vertices[j] == vertices[j + 1])
{
continue;
}
for (int i = j; i < j + 3; i++)
{
var v = vertices[i];
var distance = Vector3.Distance(v, query.Epicenter);
if (distance < query.Radius)
{
var forceChange = query.GetForceChange(distance);
var distanceToCenter = Vector3.Distance(v, _center);
if (Math.Abs(_radius - distanceToCenter + forceChange) > query.OffsetThreshold)
{
// collapse triangle into point
var firstVertIndex = i - i % 3;
vertices[firstVertIndex + 1] = vertices[firstVertIndex];
vertices[firstVertIndex + 2] = vertices[firstVertIndex];
destroyed += 3;
break;
}
var forceDirection = (_center - v).normalized;
vertices[i] = v + forceChange * forceDirection;
modified++;
}
}
}
return(new MeshQuery.Result(vertices)
{
DestroyedVertices = destroyed,
ModifiedVertices = modified
});
}
/// <inheritdoc />
public override MeshQuery.Result Modify(MeshQuery query)
{
int startIndex = 0;
int destroyed = 0;
int modified = 0;
for (int j = 0; j < _planeIndices.Length; j++)
{
var endIndex = j == _planeIndices.Length - 1 ? _vertexCount : _planeIndices[j + 1];
var n = _normals[j];
var magnitude = _magnitudes[j];
var d = _coeffDs[j];
var result = base.Modify(query, startIndex, endIndex, n, magnitude, d);
destroyed += result.DestroyedVertices;
modified += result.ModifiedVertices;
startIndex = endIndex;
}
return(new MeshQuery.Result(query.Vertices)
{
ModifiedVertices = modified,
DestroyedVertices = destroyed
});
}
public override List <QueryResponse> Validate(ExecutionContext context, MeshDataCommand command, IDictionary <string, object> config, string id, MeshQuery query)
{
throw new NotImplementedException();
}
public override bool Accept(MeshDataCommand command, MeshQuery query, IEntity entity)
{
return(command.ProviderId == this.GetProviderId() && query.Action == ActionType.UPDATE && EntityType.Contains(entity.EntityType));
}
public override List <QueryResponse> Validate(ExecutionContext context, RemoveFromProcessingDataCommand command, IDictionary <string, object> config, string id, MeshQuery query)
{
var hubSpotCrawlJobData = new HubSpotCrawlJobData(config);
var quereis = new List <QueryResponse>();
var client = new RestClient("https://api.hubapi.com");
var request = new RestRequest(string.Format("/automation/v2/workflows/enrollments/contacts/{0}", id), Method.GET);
request.AddQueryParameter("hapikey", hubSpotCrawlJobData.ApiToken); // adds to POST or URL querystring based on Method
var result = client.ExecuteTaskAsync <List <Workflow> >(request).Result;
return(new List <QueryResponse>()
{
new QueryResponse()
{
Content = result.Content, StatusCode = result.StatusCode
}
});
}
/* TODO remove comment and implement the override for Accept method in your derived Provider class if requiring more functionality beyond the base class implementation
* public override bool Accept(MeshDataCommand command, MeshQuery query, IEntity entity)
* {
* // TODO filter on action
* // e.g. query.Action == ActionType.*;
* return base.Accept(command, query, entity);
* }
*/
public override void DoProcess(ExecutionContext context, MeshDataCommand command, IDictionary <string, object> jobData, MeshQuery query)
{
throw new NotImplementedException();
}
public override bool Accept(RemoveFromProcessingDataCommand command, MeshQuery query, IEntity entity)
{
return(command.ProviderId == this.GetProviderId() && query.Action == ActionType.DISASSOCIATE && EntityType.Contains(entity.EntityType));
}
public override List <QueryResponse> Validate(ExecutionContext context, MeshDataCommand command, IDictionary <string, object> config, string id, MeshQuery query)
{
var serviceNowCrawlJobData = new ServiceNowCrawlJobData(config);
var client = new RestClient(string.Format("{0}/api/now/table", serviceNowCrawlJobData.BaseUrl));
var request = new RestRequest(EditUrl, Method.GET);
client.Authenticator = new HttpBasicAuthenticator(serviceNowCrawlJobData.Username, serviceNowCrawlJobData.Password);
var result = client.ExecuteTaskAsync(request).Result;
return(new List <QueryResponse>()
{
new QueryResponse()
{
Content = result.Content, StatusCode = result.StatusCode
}
});
}
public override bool Accept(MeshDataCommand command, MeshQuery query, IEntity entity)
{
return(true);
}
/// <inheritdoc />
public virtual MeshQuery.Result Modify(MeshQuery query)
{
return(Modify(query, 0, query.Vertices.Length / 2, _n, _normalMagnitude, _d));
}
public override List <QueryResponse> Validate(ExecutionContext context, MeshDataCommand command, IDictionary <string, object> config, string id, MeshQuery query)
{
var item = ActionExtensions.ExecuteWithRetry(() => { return(graphClient.Drive.Items[id].Request().GetAsync().Result); });
if (item == null)
{
return new List <QueryResponse>()
{
new QueryResponse()
{
Content = null, StatusCode = System.Net.HttpStatusCode.InternalServerError
}
}
}
;
//TODO search file content
return(new List <QueryResponse>()
{
new QueryResponse()
{
Content = JsonConvert.SerializeObject(item), StatusCode = System.Net.HttpStatusCode.OK
}
});
}
public override List <QueryResponse> Validate(ExecutionContext context, MeshDataCommand command, IDictionary <string, object> config, string id, MeshQuery query)
{
return(new List <QueryResponse>()
{
new QueryResponse()
{
Content = string.Empty, StatusCode = System.Net.HttpStatusCode.OK
}
});
}
public override void DoProcess(CluedIn.Core.ExecutionContext context, MeshDataCommand command, IDictionary <string, object> jobData, MeshQuery query)
{
return;
}
public override List <QueryResponse> Validate(ExecutionContext context, MeshDataCommand command, IDictionary <string, object> config, string id, MeshQuery query)
{
var hubSpotCrawlJobData = new HubSpotCrawlJobData(config);
var client = new RestClient("https://api.hubapi.com");
var request = new RestRequest(string.Format(EditUrl + "{0}", id), Method.GET);
request.AddQueryParameter("hapikey", hubSpotCrawlJobData.ApiToken); // adds to POST or URL querystring based on Method
var result = client.ExecuteTaskAsync(request).Result;
return(new List <QueryResponse>()
{
new QueryResponse()
{
Content = result.Content, StatusCode = result.StatusCode
}
});
}
/// <inheritdoc />
public MeshQuery.Result Modify(MeshQuery query)
{
return(new MeshQuery.Result(query.Vertices));
}
