| public static s2eNorm ( double sNorm ) : double | ||
| sNorm | double | |
| return | double | |
/// <summary>
/// A correct implementation of shrink tile.
/// hmmmm, is "scaling" even well defined in non-E geometries? Am I really looking for an equidistant curve?
/// Sadly, even if I figure out what is best, I fear changing out usage of the incorrect one below in MagicTile,
/// because of the possibility of breaking existing puzzles.
/// </summary>
internal static void ShrinkTileCorrect(ref Tile tile, double shrinkFactor)
{
System.Func <Vector3D, double, Vector3D> scaleFunc = null;
switch (tile.Geometry)
{
case Geometry.Euclidean:
{
scaleFunc = (v, s) => v * s;
break;
}
case Geometry.Spherical:
{
scaleFunc = (v, s) =>
{
// Move to spherical norm, scale, then move back to euclidean.
double scale = Spherical2D.s2eNorm((Spherical2D.e2sNorm(v.Abs()) * s));
v.Normalize();
return(v * scale);
};
break;
}
case Geometry.Hyperbolic:
{
throw new System.NotImplementedException();
}
}
}
public static double GetNormalizedCircumRadius(int p, double q)
{
double hypot = GetTriangleHypotenuse(p, q);
switch (Geometry2D.GetGeometry(p, q))
{
case Geometry.Spherical:
return(Spherical2D.s2eNorm(hypot) * DiskRadius);
case Geometry.Euclidean:
return(EuclideanHypotenuse);
case Geometry.Hyperbolic:
{
if (Infinity.IsInfinite(hypot))
{
return(DiskRadius);
}
return(DonHatch.h2eNorm(hypot) * DiskRadius);
}
}
Debug.Assert(false);
return(1);
}
public static void CalcEScale()
{
// Euclidean scale is arbitrary, but put it in the middle of the projections of 433 and 435.
double r3 = Spherical2D.s2eNorm(Honeycomb.CircumRadius(4, 3, 3));
double r5 = DonHatch.h2eNorm(Honeycomb.CircumRadius(4, 3, 5));
m_eScale = (r3 + r5) / (2 * Math.Sqrt(3));
}
public static Vector3D EdgeMidpointSpherical(int p, int q, int r)
{
// Get a {q,p} tiling on the z=0 plane.
Segment[] baseTileSegments = BaseTileSegments(q, p);
Vector3D direction = H3Models.UHSToBall(baseTileSegments.First().Midpoint);
direction.Normalize();
double midRadius = Spherical2D.s2eNorm(Honeycomb.MidRadius(p, q, r));
return(direction * midRadius);
}
public static Vector3D FaceCenterSpherical(int p, int q, int r)
{
// Get a {q,p} tiling on the z=0 plane.
Segment[] baseTileSegments = BaseTileSegments(q, p);
// This will be unit length.
Vector3D pFaceDirection = H3Models.UHSToBall(baseTileSegments.First().P1);
// In-radius is in conformal model
double inRadius = Spherical2D.s2eNorm(Honeycomb.InRadius(p, q, r));
return(pFaceDirection * inRadius);
}
/// <summary>
/// Helper to project points from S3 -> S2, then add an associated curve.
/// </summary>
private static void ProjectAndAddS3Points(Shapeways mesh, Vector3D[] pointsS3, bool shrink)
{
// Project to S3, then to R3.
List <Vector3D> projected = new List <Vector3D>();
foreach (Vector3D v in pointsS3)
{
v.Normalize();
Vector3D c = v.ProjectTo3DSafe(1.0);
// Pull R3 into a smaller open disk.
if (shrink)
{
double mag = Math.Atan(c.Abs());
c.Normalize();
c *= mag;
}
projected.Add(c);
}
System.Func <Vector3D, double> sizeFunc = v =>
{
// Constant thickness.
// return 0.08;
double sphericalThickness = 0.002;
double abs = v.Abs();
if (shrink)
{
abs = Math.Tan(abs); // The unshrunk abs.
}
// The thickness at this vector location.
double result = Spherical2D.s2eNorm(Spherical2D.e2sNorm(abs) + sphericalThickness) - abs;
if (shrink)
{
result *= Math.Atan(abs) / abs; // shrink it back down.
}
return(result);
};
mesh.AddCurve(projected.ToArray(), sizeFunc);
}
public static double GetNormalizedCircumRadius(int p, int q)
{
Geometry g = Geometry2D.GetGeometry(p, q);
double hypot = GetTriangleHypotenuse(p, q);
switch (g)
{
case Geometry.Spherical:
return(Spherical2D.s2eNorm(hypot) * DiskRadius);
case Geometry.Euclidean:
return(EuclideanHypotenuse);
case Geometry.Hyperbolic:
return(DonHatch.h2eNorm(hypot) * DiskRadius);
}
Debug.Assert(false);
return(1);
}
/// <summary>
/// Mirrors for Spherical geometry, in the ball model.
/// </summary>
public static Sphere[] MirrorsSpherical(int p, int q, int r)
{
// Get a {q,p} tiling on the z=0 plane.
Segment[] baseTileSegments = BaseTileSegments(q, p);
// This will be unit length.
Vector3D pFaceDirection = H3Models.UHSToBall(baseTileSegments.First().P1);
// In-radius is in conformal model
double inRadius = Spherical2D.s2eNorm(Honeycomb.InRadius(p, q, r));
double centerOfSphereNE = (1 - inRadius) / (1 + inRadius);
Vector3D center;
double radius;
H3Models.Ball.DupinCyclideSphere(-pFaceDirection * centerOfSphereNE, 1.0 /*geodesic circle*/, Geometry.Spherical, out center, out radius);
Sphere cellBoundary = new Sphere()
{
Center = center, Radius = radius, Invert = true
};
Sphere[] interior = InteriorMirrors(p, q);
interior = interior.Select(s => H3Models.UHSToBall(s)).ToArray();
Sphere[] surfaces = new Sphere[] { cellBoundary, interior[0], interior[1], interior[2] };
// Apply rotations.
bool applyRotations = false;
if (applyRotations)
{
double rotation = Math.PI / 2;
foreach (Sphere s in surfaces)
{
RotateSphere(s, rotation);
}
}
return(surfaces);
}
public static Sphere[] Mirrors(int p, int q, int r, ref Vector3D cellCenter, bool moveToBall = true, double scaling = -1)
{
Geometry g = Util.GetGeometry(p, q, r);
if (g == Geometry.Spherical)
{
// These are in the ball model.
Sphere[] result = SimplexCalcs.MirrorsSpherical(p, q, r);
return(result);
}
else if (g == Geometry.Euclidean)
{
return(SimplexCalcs.MirrorsEuclidean());
}
// This is a rotation we'll apply to the mirrors at the end.
// This is to try to make our image outputs have vertical bi-lateral symmetry and the most consistent in all cases.
// NOTE: + is CW, not CCW. (Because the way I did things, our images have been reflected vertically, and I'm too lazy to go change this.)
double rotation = Math.PI / 2;
// Some construction points we need.
Vector3D p1, p2, p3;
Segment seg = null;
TilePoints(p, q, out p1, out p2, out p3, out seg);
//
// Construct in UHS
//
Geometry cellGeometry = Geometry2D.GetGeometry(p, q);
Vector3D center = new Vector3D();
double radius = 0;
if (cellGeometry == Geometry.Spherical)
{
// Finite or Infinite r
// Spherical trig
double halfSide = Geometry2D.GetTrianglePSide(q, p);
double mag = Math.Sin(halfSide) / Math.Cos(Util.PiOverNSafe(r));
mag = Math.Asin(mag);
// e.g. 43j
//mag *= 0.95;
// Move mag to p1.
mag = Spherical2D.s2eNorm(mag);
H3Models.Ball.DupinCyclideSphere(p1, mag, Geometry.Spherical, out center, out radius);
}
else if (cellGeometry == Geometry.Euclidean)
{
center = p1;
radius = p1.Dist(p2) / Math.Cos(Util.PiOverNSafe(r));
}
else if (cellGeometry == Geometry.Hyperbolic)
{
if (Infinite(p) && Infinite(q) && FiniteOrInfinite(r))
{
//double iiiCellRadius = 2 - Math.Sqrt( 2 );
//Circle3D iiiCircle = new Circle3D() { Center = new Vector3D( 1 - iiiCellRadius, 0, 0 ), Radius = iiiCellRadius };
//radius = iiiCellRadius; // infinite r
//center = new Vector3D( 1 - radius, 0, 0 );
// For finite r, it was easier to calculate cell facet in a more symmetric position,
// then move into position with the other mirrors via a Mobius transformation.
double rTemp = 1 / (Math.Cos(Util.PiOverNSafe(r)) + 1);
Mobius m = new Mobius();
m.Isometry(Geometry.Hyperbolic, -Math.PI / 4, new Vector3D(0, Math.Sqrt(2) - 1));
Vector3D c1 = m.Apply(new Vector3D(1 - 2 * rTemp, 0, 0));
Vector3D c2 = c1;
c2.Y *= -1;
Vector3D c3 = new Vector3D(1, 0);
Circle3D c = new Circle3D(c1, c2, c3);
radius = c.Radius;
center = c.Center;
}
else if (Infinite(p) && Finite(q) && FiniteOrInfinite(r))
{
// http://www.wolframalpha.com/input/?i=r%2Bx+%3D+1%2C+sin%28pi%2Fp%29+%3D+r%2Fx%2C+solve+for+r
// radius = 2 * Math.Sqrt( 3 ) - 3; // Appolonian gasket wiki page
//radius = Math.Sin( Math.PI / q ) / ( Math.Sin( Math.PI / q ) + 1 );
//center = new Vector3D( 1 - radius, 0, 0 );
// For finite r, it was easier to calculate cell facet in a more symmetric position,
// then move into position with the other mirrors via a Mobius transformation.
double rTemp = 1 / (Math.Cos(Util.PiOverNSafe(r)) + 1);
Mobius m = new Mobius();
m.Isometry(Geometry.Hyperbolic, 0, p2);
Vector3D findingAngle = m.Inverse().Apply(new Vector3D(1, 0));
double angle = Math.Atan2(findingAngle.Y, findingAngle.X);
m.Isometry(Geometry.Hyperbolic, angle, p2);
Vector3D c1 = m.Apply(new Vector3D(1 - 2 * rTemp, 0, 0));
Vector3D c2 = c1;
c2.Y *= -1;
Vector3D c3 = new Vector3D(1, 0);
Circle3D c = new Circle3D(c1, c2, c3);
radius = c.Radius;
center = c.Center;
}
else if (Finite(p) && Infinite(q) && FiniteOrInfinite(r))
{
radius = p2.Abs(); // infinite r
radius = DonHatch.asinh(Math.Sinh(DonHatch.e2hNorm(p2.Abs())) / Math.Cos(Util.PiOverNSafe(r))); // hyperbolic trig
// 4j3
//m_jOffset = radius * 0.02;
//radius += m_jOffset ;
radius = DonHatch.h2eNorm(radius);
center = new Vector3D();
rotation *= -1;
}
else if (/*Finite( p ) &&*/ Finite(q))
{
// Infinite r
//double mag = Geometry2D.GetTrianglePSide( q, p );
// Finite or Infinite r
double halfSide = Geometry2D.GetTrianglePSide(q, p);
double mag = DonHatch.asinh(Math.Sinh(halfSide) / Math.Cos(Util.PiOverNSafe(r))); // hyperbolic trig
H3Models.Ball.DupinCyclideSphere(p1, DonHatch.h2eNorm(mag), out center, out radius);
}
else
{
throw new System.NotImplementedException();
}
}
Sphere cellBoundary = new Sphere()
{
Center = center,
Radius = radius
};
Sphere[] interior = InteriorMirrors(p, q);
Sphere[] surfaces = new Sphere[] { cellBoundary, interior[0], interior[1], interior[2] };
// Apply rotations.
bool applyRotations = true;
if (applyRotations)
{
foreach (Sphere s in surfaces)
{
RotateSphere(s, rotation);
}
p1.RotateXY(rotation);
}
// Apply scaling
bool applyScaling = scaling != -1;
if (applyScaling)
{
//double scale = 1.0/0.34390660467269524;
//scale = 0.58643550768408892;
foreach (Sphere s in surfaces)
{
Sphere.ScaleSphere(s, scaling);
}
}
bool facetCentered = false;
if (facetCentered)
{
PrepForFacetCentering(p, q, surfaces, ref cellCenter);
}
// Move to ball if needed.
if (moveToBall)
{
surfaces = MoveToBall(surfaces, ref cellCenter);
}
return(surfaces);
}
public static Vector3D VertexSpherical(int p, int q, int r)
{
double circumRadius = Spherical2D.s2eNorm(Honeycomb.CircumRadius(p, q, r));
return(new Vector3D(0, 0, -circumRadius));
}