public static void AddLane(Curve3DSampler l,
out List <Lane> added, out List <Lane> deleted)
{
// Variable has not been actually calculated until "ToList()" is called
var lane_intersections = from lane in allLanes
let intersections = lane.IntersectWith(l)
where intersections.Count > 0
select(lane, intersections);
if (lane_intersections.ToList().Count > 0)
{
Debug.Log("From " + allLanes.Count + " found # intersections: " + lane_intersections.ToList()[0].intersections.Count);
}
added = new List <Lane>();
deleted = new List <Lane>();
List <float> l_intersect_params = new List <float>();
// replacements
foreach (var lane_intersection in lane_intersections.ToList())
{
Lane old_lane;
List <Vector3> intersection;
(old_lane, intersection) = lane_intersection;
List <float> intersection_params = intersection.ConvertAll(input => old_lane.xz_curve.ParamOf(Algebra.toVector2(input)).Value);
List <Curve3DSampler> splitted = old_lane.MultiCut(intersection_params, old_lane.xz_curve.Length);
//remove old lanes & destroy objects.
old_lane.SetGameobjVisible(false);
allLanes.Remove(old_lane);
deleted.Add(old_lane);
//create replacements
var replaced_lanes = splitted.ConvertAll(sampler => new Lane(sampler));
added.AddRange(replaced_lanes);
//store intersection points on l
intersection.ForEach(input =>
l_intersect_params.Add(l.xz_curve.ParamOf(Algebra.toVector2(input)).Value));
}
// create new lane
List <Curve3DSampler> l_splitted = l.MultiCut(l_intersect_params, l.xz_curve.Length);
var new_lanes = l_splitted.ConvertAll(sampler => new Lane(sampler));
added.AddRange(new_lanes);
Debug.Log(new_lanes.Count + "newly added");
// Update record
allLanes.AddRange(added);
OnMapChanged?.Invoke(null, allLanes);
}
public static Curve TryInit(Vector2 _start, float angle, Vector2 _end, float _z_start = 0f, float _z_end = 0f)
{
Arc candidate = new Arc(_start, angle, _end, _z_start, _z_end);
if (Algebra.isclose(candidate.length, 0f))
{
return(null);
}
else
{
return(candidate);
}
}
public void Reduce()
{
long GDC = Algebra.GreatestCommonDivisor(Numerator, Denominator);
Numerator /= GDC;
Denominator /= GDC;
if (Denominator < 0)
{
Denominator *= -1;
Numerator *= -1;
}
}
/// <summary>
/// tries to return the one dimensional array 'targert' to its original two dimensional array.
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public static T[,] Expande(T[] target, int firstDimension)
{
T[,] r = new T[firstDimension, Algebra.Round(target.Length / firstDimension)];
int target_index = 0;;
for (int i = 0; i < firstDimension; i++)
{
for (int j = 0; j < r.GetLength(1); j++, target_index++)
{
r[i, j] = target[target_index];
}
}
return(r);
}
private void BtnCubeRoot_Click(object sender, EventArgs e)
{
//if there's input call the Third library and perform the cube root function
if (CheckForInput(tbResult.Text))
{
tbResult.Text = Algebra.CubeRoot(double.Parse(tbResult.Text)).ToString();
isTotal = true;
}
//if there's no input or input is invalid print error to user
else
{
MessageBox.Show("Please enter valid input");
}
}
public FiniteFieldElement <IntegerType> [] GetElements()
{
if (1000000 < ElementCount)
{
throw new Exception("Groups is to big, you do not want this");
}
FiniteFieldElement <IntegerType> [] elements = new FiniteFieldElement <IntegerType> [(int)ElementCount];
for (int index = 0; index < elements.Length; index++)
{
elements[index] = new FiniteFieldElement <IntegerType>(this, Algebra.ToDomain(index));
}
return(elements);
}
public static Curve TryInit(Vector3 _center, Vector3 _start, float angle)
{
Arc candidate = new Arc(_center, _start, angle);
if (Algebra.isclose(candidate.length, 0f))
{
Debug.LogWarning("try creating Arc of zero length!");
return(null);
}
else
{
return(candidate);
}
}
public static Curve TryInit(Vector3 _start, Vector3 _end)
{
Line candidate = new Line(_start, _end);
if (Algebra.isclose(candidate.length, 0f))
{
Debug.LogWarning("try creating Line of zero length!");
return(null);
}
else
{
return(candidate);
}
}
public void DoAlgebra()
{
SetWork(new Steps(equation));
if (IsTimeKnown())
{
Algebra.solveEquation(false, this.work, leftSide, rightSide, GetMissingQuantityIndex());
}
else
{
Algebra.solveEquation(true, this.work, leftSide, rightSide, GetMissingQuantityIndex());
}
SetQuantity(GetMissingQuantityIndex(), this.work.GetNumericalAnswer().ToString()); //adds answer to array and updates knowns
}
public void TestDiagonal()
{
var a = new DenseDoubleMatrix2D(new[]
{
new[] { 5d, 2d, 4d },
new[] { -3d, 6d, 2d },
new[] { 3d, -3d, 1d }
});
var principal = DoubleFactory2D.Dense.Diagonal(a);
Assert.AreEqual(5d, principal[0]);
Assert.AreEqual(6d, principal[1]);
Assert.AreEqual(1d, principal[2]);
Assert.AreEqual(12d, Algebra.Trace(a));
}
public void DoAlgebra()
{
SetWork(new Steps(equation));
if (!IsTimeKnown())
{
Algebra.getPositiveQuadraticRoot(work, 0.5f * GetNumericalQuantity(3), GetNumericalQuantity(0), -1 * GetNumericalQuantity(4));
}
else
{
Algebra.solveEquation(false, work, leftSide, rightSide, GetMissingQuantityIndex());
}
SetQuantity(GetMissingQuantityIndex(), this.work.GetNumericalAnswer().ToString()); //adds answer to array and updates knowns
}
public bool findNodeAt(Vector3 position, out Node rtn)
{
Vector3 approx = Algebra.approximate(position);
if (allnodes.ContainsKey(approx))
{
rtn = allnodes[approx];
return(true);
}
else
{
rtn = null;
return(false);
}
}
public bool contains(Vector3 point)
{
Vector2 twod_point = new Vector2(point.x, point.z);
//Debug.Log("param of " + point + " is " + paramOf(twod_point));
if (paramOf(twod_point) != null && 0 <= (float)paramOf(twod_point) && (float)paramOf(twod_point) <= 1f)
{
//Debug.Log((this.at((float)paramOf(twod_point)) - point).magnitude.ToString("C4"));
return(Algebra.isclose(this.at((float)paramOf(twod_point)), point));
}
else
{
return(false);
}
}
public void NewTestScriptSimplePasses()
{
Curve c = Arc.TryInit(roadPoints[0], roadPoints[1], Mathf.PI / 2);
Curve cr = c.reversed();
Assert.True(Algebra.isclose(c.At(0f), cr.At(1f)));
float a1 = c.Angle_2d(1f);
float a2 = cr.Angle_2d(0f);
//float angleDiff = (a2 - a1) / Mathf.PI;
Debug.Log(a1);
Debug.Log(a2);
Assert.True(Algebra.isclose(a2, Mathf.PI / 2));
}
/// <summary>
/// Attracts the p to curve. Default implementation uses a binary search
/// </summary>
/// <returns>If the curve is not in radius distance, then just return p</returns>
public virtual Vector2 GetAttractedPoint(Vector2 p, float attract_radius)
{
Algebra.Del _Distance = (t) => (_GetTwodPos(t) - p).sqrMagnitude;
float close_scaled_t = Algebra.MinArg(_Distance, 0.5f, 0f, 1f);
Vector2 closest_p = _GetTwodPos(close_scaled_t);
if ((closest_p - p).sqrMagnitude <= attract_radius * attract_radius)
{
return(closest_p);
}
else
{
return(p);
}
}
/// <summary>
/// <para> start turns angle clockwise around center and arrives at end</para>
/// </summary>
/// <param name="angle">Can be negative</param>
public Arc(Vector2 start, float angle, Vector2 end)
{
Debug.Assert(Mathf.Abs(angle) < Mathf.PI * 2);
controlPoints = new Vector2[3];
var bottom_angle = (Mathf.PI - angle) * 0.5f;
Center = start + Algebra.RotatedY(end - start, -bottom_angle) * 0.5f / Mathf.Sin(angle / 2);
Radius = (Center - start).magnitude;
var radialDir = start - Center;
t_start = Mathf.Atan2(radialDir.y, radialDir.x);
t_end = t_start + angle;
Start = GetTwodPos(0f);
End = GetTwodPos(1f);
}
/*<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
/*inverse of lengthByParam*/
public float ParamByLength(float l, bool usebuff = false)
{
if (usebuff)
{
//return paramByLengthBuffer[Mathf.CeilToInt(l / bufferResolution)];
int a = Mathf.FloorToInt(l / bufferResolution);
int b = a + 1;
float aLength = a * Length / (bufferLength - 1);
float bLength = b * Length / (bufferLength - 1);
return(Algebra.genericScalarIntepolator(paramByLengthBuffer[a], paramByLengthBuffer[b], l - aLength, bLength - l));
}
else
{
return(paramByLength(l));
}
}
/*<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
/*curve's length from param 0 to param t*/
public float LengthByParam(float t, bool usebuff = false)
{
if (usebuff && 0 <= t && t <= 1)
{
//return lengthByParamBuffer[Mathf.CeilToInt(t * length / bufferResolution)];
int a = Mathf.FloorToInt(t * Length / bufferResolution);
int b = a + 1;
float aParam = a * 1f / (bufferLength - 1);
float bParam = b * 1f / (bufferLength - 1);
return(Algebra.genericScalarIntepolator(lengthByParamBuffer[a], lengthByParamBuffer[b], t - aParam, bParam - t));
}
else
{
return(lengthByParam(t));
}
}
/*<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
public Vector3 FrontNormal(float t, bool usebuff = false)
{
if (usebuff && 0 <= t && t <= 1)
{
//return frontNormalBuffer[Mathf.CeilToInt(t * length / bufferResolution)];
int a = Mathf.FloorToInt(t * Length / bufferResolution);
int b = a + 1;
float aParam = a * 1f / (bufferLength - 1);
float bParam = b * 1f / (bufferLength - 1);
return(Algebra.unitVecInterpolator(frontNormalBuffer[a], frontNormalBuffer[b], t - aParam, bParam - t));
}
else
{
return(frontNormal(t));
}
}
/// <summary>
///
/// </summary>
/// <param name="point1"></param>
/// <param name="point2"></param>
/// <param name="radius"></param>
/// <returns></returns>
public static Point[] CircleLineIntersect(Point point1, Point point2, double radius)
{
Offset delta = new Offset(point1, point2);
double determinant = point1.CrossProduct(point2);
double lineLength = Algebra.SRSS(delta.X(), delta.Y());
double incidence = incidenceLineCircle(radius, lineLength, determinant);
double[] xCoords = CircleLineIntersectX(radius, lineLength, incidence, determinant, delta);
double[] yCoords = CircleLineIntersectY(radius, lineLength, incidence, determinant, delta);
return(new[]
{
new Point(xCoords[0], yCoords[0]),
new Point(xCoords[1], yCoords[1])
});
}
/*resulting curve: Length = Original * (end - start)*/
public Curve cut(float start, float end)
{
end = Mathf.Max(start, end);
if (this is Line || this is Arc)
{
Curve rtn;
if (start < 0f && !Algebra.isclose(start, 0f) || end > 1f && !Algebra.isclose(end, 1f))
{
Debug.Log("Abnormal cut, start:" + start + "end:" + end);
throw new InvalidOperationException();
}
Curve secondAndThird = Algebra.isclose(start, 0f) ? this : split(start).Last();
if (!Algebra.isclose(end, 1f))
{
Curve third = split(end).Last();
float secondFraction = (secondAndThird.length - third.length) / secondAndThird.length;
rtn = secondAndThird.split(secondFraction).First();
}
else
{
if (!Algebra.isclose(start, 0f))
{
rtn = secondAndThird;
}
else
{
rtn = segmentation(this.length).First();
}
}
if (Mathf.Abs(rtn.at(0f).y - this.at(end).y) < Mathf.Abs(rtn.at(1f).y - this.at(end).y))
{
rtn.reverse();
rtn.z_start = rtn.z_start + rtn.z_offset;
rtn.z_offset = -rtn.z_offset;
}
return(rtn);
}
else
{
Vector2 p1 = this.at_ending_2d(true, start * length);
Vector2 p2 = this.at_ending_2d(false, (1f - end) * length);
Curve rtn = deepCopy();
rtn.t_start = toGlobalParam(paramOf(p1).Value);
rtn.t_end = toGlobalParam(paramOf(p2).Value);
return(rtn);
}
}
public void DoAlgebra()
{
Expression leftSide = new UnaryExpression(GetQuantity(4));
Expression rightSide = new BinaryExpression(new BinaryExpression(new UnaryExpression(GetQuantity(1)), new UnaryExpression(GetQuantity(2)), '*'), new BinaryExpression(new BinaryExpression("0.5", new UnaryExpression(GetQuantity(3)), '*'), new BinaryExpression(new UnaryExpression(GetQuantity(2)), "2", '^'), '*'), '-');
SetWork(new Steps(equation));
if (!IsTimeKnown())
{
Algebra.getPositiveQuadraticRoot(work, -0.5f * GetNumericalQuantity(3), GetNumericalQuantity(1), -1 * GetNumericalQuantity(4));
}
else
{
Algebra.solveEquation(false, this.work, leftSide, rightSide, GetMissingQuantityIndex());
}
SetQuantity(GetMissingQuantityIndex(), this.work.GetNumericalAnswer().ToString()); //adds answer to array and updates knowns
}
public void AreCoprime()
{
Algebra.AreCoprime(6, 1).ShouldBeTrue();
Algebra.AreCoprime(6, 5).ShouldBeTrue();
Algebra.AreCoprime(6, 2).ShouldBeFalse();
Algebra.AreCoprime(6, 3).ShouldBeFalse();
Algebra.AreCoprime(6, 4).ShouldBeFalse();
Algebra.AreCoprime(6, 6).ShouldBeFalse();
Algebra.AreCoprime(-2, 4).ShouldBeFalse();
Algebra.AreCoprime(-2, -4).ShouldBeFalse();
Algebra.AreCoprime(2, -4).ShouldBeFalse();
Algebra.AreCoprime(-2, 3).ShouldBeTrue();
Algebra.AreCoprime(-2, -3).ShouldBeTrue();
Algebra.AreCoprime(2, -3).ShouldBeTrue();
}
private static WriteableBitmap CubeH(int cubeWidth, double columnY)
{
Algebra.DividePlane(cubeWidth, cubeWidth, _cores, out var dic);
var length = dic.Count;
var stride = cubeWidth * 4;
var a = new byte[stride * cubeWidth];
var step = 1.0 / cubeWidth;
var h = 360.0 - columnY * 360.0;
Parallel.For(0, length, i =>
{
var d = dic[i];
var str = stride;
for (var y = d[1]; y < d[1] + d[3]; y++)
{
for (var x = d[0]; x < d[0] + d[2]; x++)
{
var n = y * str + x * 4;
var hsb = new Hsb
{
H = h,
S = step * x,
B = 1.0 - step * y
};
var rgb = hsb.To <Rgb>();
var r = (byte)Math.Round(rgb.R);
var g = (byte)Math.Round(rgb.G);
var b = (byte)Math.Round(rgb.B);
a[n] = b;
a[n + 1] = g;
a[n + 2] = r;
a[n + 3] = 255;
}
}
});
var rect = new Int32Rect(0, 0, cubeWidth, cubeWidth);
var img = new WriteableBitmap(cubeWidth, cubeWidth, 96, 96, PixelFormats.Bgr32, null);
img.Lock();
img.WritePixels(rect, a, stride, 0);
img.Unlock();
img.Freeze();
return(img);
}
public static void Test()
{
Console.WriteLine();
Console.WriteLine("AlgebraExt test");
var evalExpr = CreateTestExprExt(new EvalAlgebraExt());
Console.WriteLine($" 4 * (5 + 6) = {evalExpr.Eval()}");
var printExprA = Algebra.CreateTestExpr(new PrintAlgebra());
Console.WriteLine($" Print: {printExprA.Print()}");
var printExprB = CreateTestExprExt(new PrintAlgebra());
Console.WriteLine($" Print: {printExprB.Print()}");
}
void drawLinear2DObject(Curve curve, Linear2DObject sep)
{
float margin_0 = sep.margin_0;
float margin_1 = sep.margin_1;
if (Algebra.isclose(margin_0 + margin_1, curve.length))
{
return;
}
Debug.Assert(margin_0 + margin_1 < curve.length);
if (margin_0 + margin_1 > curve.length)
{
return;
}
if (curve.length > 0 && (margin_0 > 0 || margin_1 > 0))
{
curve = curve.cut(margin_0 / curve.length, 1f - margin_1 / curve.length);
}
if (!sep.dashed)
{
GameObject rendins = Instantiate(rend, transform);
CurveRenderer decomp = rendins.GetComponent <CurveRenderer> ();
decomp.CreateMesh(curve, sep.width, sep.material, offset: sep.offset, z_offset: 0.02f);
}
else
{
List <Curve> dashed = curve.segmentation(dashLength + dashInterval);
if (!Algebra.isclose(dashed.Last().length, dashLength + dashInterval))
{
dashed.RemoveAt(dashed.Count - 1);
}
foreach (Curve singledash in dashed)
{
List <Curve> vacant_and_dashed = singledash.split(dashInterval / (dashLength + dashInterval));
if (vacant_and_dashed.Count == 2)
{
GameObject rendins = Instantiate(rend, transform);
CurveRenderer decomp = rendins.GetComponent <CurveRenderer> ();
decomp.CreateMesh(vacant_and_dashed [1], sep.width, sep.material, offset: sep.offset, z_offset: 0.02f);
}
}
}
}
void addAngleDrawing(Vector3 positionMaybeOnRoad, Vector3 anotherPosition)
{
Node n;
List <Vector2> neighborDirs;
if (roadManager.findNodeAt(positionMaybeOnRoad, out n))
{
neighborDirs = n.getNeighborDirections(Algebra.toVector2(anotherPosition - positionMaybeOnRoad));
}
else
{
Road tar;
roadManager.approxNodeToExistingRoad(positionMaybeOnRoad, out tar);
if (tar == null)
{
return;
}
float?param = tar.curve.paramOf(positionMaybeOnRoad);
if (param == null)
{
return;
}
neighborDirs = new List <Vector2>()
{
tar.curve.direction_2d((float)param), -tar.curve.direction_2d((float)param)
};
}
foreach (Vector2 dir in neighborDirs)
{
Debug.Assert(!Algebra.isclose(dir, Vector2.zero));
Vector3 textPosition = positionMaybeOnRoad + ((anotherPosition - positionMaybeOnRoad).normalized + Algebra.toVector3(dir).normalized).normalized * textDistance;
GameObject textObj = Instantiate(degreeTextPrefab, textPosition, Quaternion.Euler(90f, 0f, 0f));
textObj.transform.SetParent(transform);
textObj.GetComponent <TextMesh>().text = Mathf.RoundToInt(Mathf.Abs(Vector2.Angle(Algebra.toVector2(anotherPosition - positionMaybeOnRoad), dir))).ToString();
degreeTextInstance.Add(textObj);
GameObject indicatorObj = Instantiate(roadIndicatorPrefab, transform);
RoadRenderer indicatorConfigure = indicatorObj.GetComponent <RoadRenderer>();
indicatorConfigure.generate(Line.TryInit(positionMaybeOnRoad, positionMaybeOnRoad + Algebra.toVector3(dir) * textDistance * 2), new List <string> {
"solid_blueindi"
});
neighborIndicatorInstance.Add(indicatorObj);
}
}
internal List <Vector2> getNeighborDirections(Vector2 direction)
{
if (connection.Count <= 2)
{
return(connection.ConvertAll((input) => input.curve.direction_ending_2d(startof(input.curve))));
}
List <float> anglesFromDirection =
connection.ConvertAll((input) => Algebra.signedAngleToPositive(Vector2.SignedAngle(direction, input.curve.direction_ending_2d(startof(input.curve)))));
return(connection.FindAll((Road arg1) =>
Algebra.signedAngleToPositive(Vector2.SignedAngle(direction, arg1.curve.direction_ending_2d(startof(arg1.curve))))
== anglesFromDirection.Max()
||
Algebra.signedAngleToPositive(Vector2.SignedAngle(direction, arg1.curve.direction_ending_2d(startof(arg1.curve))))
== anglesFromDirection.Min()).
ConvertAll((input) => input.curve.direction_ending_2d(startof(input.curve))));
}
private void createOrAddtoNode(Road road)
{
List <Vector3> roadEnds = new List <Vector3> {
road.curve.at(0f), road.curve.at(1f)
};
foreach (Vector3 roadEnd in roadEnds)
{
Node candidate;
if (!findNodeAt(roadEnd, out candidate))
{
candidate = Instantiate(nodePrefab, transform).GetComponent <Node>();
candidate.position = roadEnd;
allnodes.Add(Algebra.approximate(roadEnd), candidate);
}
candidate.addRoad(road);
}
}
/*If angle>0,
* angle is in radius
*/
private Arc(Vector2 _center, Vector2 start, float angle, float _z_start = 0f, float _z_end = 0f)
{
center = _center;
radius = (start - _center).magnitude;
float t_0 = Mathf.Acos((start.x - _center.x) / radius); /*[0, Pi]*/
if (!Algebra.isclose(Mathf.Sin(t_0), (start.y - center.y) / radius))
{
t_0 = -t_0;/*[-Pi, 0]*/
}
Debug.Assert(Mathf.Abs(t_0) <= Mathf.PI);
t_start = t_0;
t_end = t_start + angle;
z_start = _z_start;
z_offset = _z_end - _z_start;
}
