/// <summary>
/// x from 0 to 4 * man.Nside
/// y from 0 to YResolution * man.Nside
/// </summary>
public Equirectangular(HealpixManager man, int yResolution = 2)
{
var collapse1PixelWidth = 4 * man.Nside / ((4 * man.Nside) + 1 /*shrinking on one pixel at width*/ + BorderWidth);
_resx = man.Nside / 90.0 * collapse1PixelWidth;
_resy = _resx * yResolution / 2;
}
public void Water_Gradient()
{
Data = new BasinData(HealpixManager, false, false //true for sphere
, -200d //, 2000d
);
var p = HealpixManager.GetP(HealpixManager.Nside - 1, HealpixManager.Nside * 1);
var basin = Data.PixMan.Pixels[p];
basin.Delta_g_meridian = -.2;
p = HealpixManager.GetP(HealpixManager.Nside * 2, HealpixManager.Nside * 2);
Data.PixMan.Pixels[p].Delta_g_meridian = .2;
p = HealpixManager.GetP(HealpixManager.Nside * 3, HealpixManager.Nside * 2);
Data.PixMan.Pixels[p].Delta_g_meridian = .2;
p = HealpixManager.GetP(HealpixManager.Nside + 5, HealpixManager.Nside * 2);
Data.PixMan.Pixels[p].Delta_g_traverse = .2;
var framesCountBy2 = 15;
Data.Cycle(delegate(int step)
{
Data.Draw(Bmp, 0, null, YResolution, Scale);
Circle(basin);
SaveBitmap(step);
return(1);
}, framesCountBy2);
}
public void PixelsInRing()
{
var man = new HealpixManager(0);
Assert.AreEqual(4, man.PixelsCountInRing(1));
Assert.AreEqual(4, man.PixelsCountInRing(2));
Assert.AreEqual(4, man.PixelsCountInRing(3));
man = new HealpixManager(1);
Assert.AreEqual(2, man.Nside);
Assert.AreEqual(4, man.PixelsCountInRing(1));
Assert.AreEqual(8, man.PixelsCountInRing(2));
Assert.AreEqual(8, man.PixelsCountInRing(3));
Assert.AreEqual(8, man.PixelsCountInRing(4));
Assert.AreEqual(8, man.PixelsCountInRing(5));
Assert.AreEqual(8, man.PixelsCountInRing(6));
Assert.AreEqual(4, man.PixelsCountInRing(7));
man = new HealpixManager(2);
Assert.AreEqual(4, man.Nside);
Assert.AreEqual(4, man.PixelsCountInRing(1));
Assert.AreEqual(8, man.PixelsCountInRing(2));
Assert.AreEqual(12, man.PixelsCountInRing(3));
Assert.AreEqual(16, man.PixelsCountInRing(4));
Assert.AreEqual(16, man.PixelsCountInRing(5));
Assert.AreEqual(16, man.PixelsCountInRing(6));
Assert.AreEqual(16, man.PixelsCountInRing(7));
Assert.AreEqual(16, man.PixelsCountInRing(8));
Assert.AreEqual(16, man.PixelsCountInRing(9));
Assert.AreEqual(16, man.PixelsCountInRing(10));
Assert.AreEqual(16, man.PixelsCountInRing(11));
Assert.AreEqual(16, man.PixelsCountInRing(12));
Assert.AreEqual(12, man.PixelsCountInRing(13));
Assert.AreEqual(8, man.PixelsCountInRing(14));
Assert.AreEqual(4, man.PixelsCountInRing(15));
}
internal override void PreInit(HealpixManager man)
{
base.PreInit(man);
var northRingPixel = man.GetCenter(Math.Max(1, P - PixelInRing));
lQn2 = (Beta.Value - northRingPixel.Beta.Value) * rOfEllipse / 2;
}
public void AbsoluteDistanceTo_Metric()
{
var man = new HealpixManager(0);
var basin = man.GetCenter <Basin3>(0);
Assert.AreEqual(0, basin.Intersect(basin));
Assert.AreEqual(0, basin.S_q.AbsoluteDistanceTo(basin.Q3));
var toBasin = man.GetCenter <Basin3>(1);
var from0to1 = basin.S_q.AbsoluteDistanceTo(toBasin.Q3);
var from1to0 = toBasin.S_q.AbsoluteDistanceTo(basin.Q3);
Assert.AreEqual(from1to0, from0to1, 1);
basin = man.GetCenter <Basin3>(4);
toBasin = man.GetCenter <Basin3>(7);
Assert.AreEqual(
basin.S_q.AbsoluteDistanceTo(toBasin.Q3),
toBasin.S_q.AbsoluteDistanceTo(basin.Q3),
.0001);
man = new HealpixManager(1);
basin = man.GetCenter <Basin3>(0);
toBasin = man.GetCenter <Basin3>(4);
// basin.SetKQQaxis(0, man);
// toBasin.SetKQQaxis(0, man);
Assert.AreEqual(
basin.S_q.AbsoluteDistanceTo(toBasin.Q3),
toBasin.S_q.AbsoluteDistanceTo(basin.Q3),
1100); //// .0001 better
}
public void GetP_2()
{
var man = new HealpixManager(2);
Assert.AreEqual(31, man.GetP(4, 8));
Assert.AreEqual(47, man.GetP(5, 8));
Assert.AreEqual(63, man.GetP(6, 8));
Assert.AreEqual(79, man.GetP(7, 8));
Assert.AreEqual(77, man.GetP(7, 6));
Assert.AreEqual(95, man.GetP(8, 8));
Assert.AreEqual(72, man.GetP(7, 1));
Assert.AreEqual(87, man.GetP(7, 16));
Assert.AreEqual(88, man.GetP(8, 1));
Assert.AreEqual(103, man.GetP(8, 16));
Assert.AreEqual(104, man.GetP(9, 1));
Assert.AreEqual(118, man.GetP(9, 15));
Assert.AreEqual(119, man.GetP(9, 16));
Assert.AreEqual(120, man.GetP(10, 1));
Assert.AreEqual(135, man.GetP(10, 16));
Assert.AreEqual(136, man.GetP(11, 1));
Assert.AreEqual(137, man.GetP(11, 2));
Assert.AreEqual(151, man.GetP(11, 16));
Assert.AreEqual(152, man.GetP(12, 1));
}
public static void DoWork()
{
var man = new HealpixManager(2);
var world = new World(man);
using (var reliefSur = new Earth2014Manager(ReliefType.Sur))
{
using (var reliefBed = new Earth2014Manager(ReliefType.Bed))
{
using (var reliefIce = new Earth2014Manager(ReliefType.Ice))
{
for (var p = 0; p < man.Npix; p++)
{
var coor = man.GetCenter(p);
var surface = reliefSur.GetAltitude(coor);
var bed = reliefBed.GetAltitude(coor);
var relativeHeight = bed - surface;
if (relativeHeight != 0)
{
// water or ice
var ice = reliefIce.GetAltitude(coor);
if (ice == 0)
{
// lakes in ice are ignored
world.AddWater(coor, bed, surface);
}
}
}
}
}
}
}
public WaterAndBottomData(HealpixManager man, double?min = null, double?max = null) : base(man, min, max)
{
ColorsMiddle = 0;
var p = 0;
for (var ring = 1; ring <= MaxRing; ring++)
{
var basin = PixMan.Pixels[ring - 1];
var waterHeightAll = 0d;
var surfaceHeightAll = 0d;
var pixelsInRing = HealpixManager.PixelsCountInRing(ring);
for (var inRing = 1; inRing < pixelsInRing; inRing++, p++)
{
var coor = HealpixManager.GetCenter <HealCoor>(p);
int waterHeight;
surfaceHeightAll += GetHeights(coor, (int)basin.rOfEllipse, out waterHeight);
waterHeightAll += waterHeight;
}
if (waterHeightAll > 0)
{
basin.hOQ = 0;
basin.Depth = waterHeightAll / pixelsInRing;
}
else
{
basin.hOQ = surfaceHeightAll / pixelsInRing;
basin.Depth = -surfaceHeightAll / pixelsInRing;
}
}
CheckOcean();
}
public void InitROfEllipse(HealpixManager man, double newR)
{
rOfEllipse = newR;
Area = newR * newR * man.OmegaPix;
RingArea = Area * PixelsCountInRing;
}
private void FindNearestPixelInRing(Point2 coor, ref int nearestPixel, out int previous)
{
var wasNearestPixel = nearestPixel;
if (ColorsManager.FindNearest(
coor.X,
P => Pixels[P].X,
false,
PrecisionGrad,
nearestPixel + HealpixManager.PixelsCountInRing(Pixels[nearestPixel].Ring),
ref nearestPixel)) // todo add approximation
{
previous = nearestPixel;
}
else
{
previous = nearestPixel - 1;
if (nearestPixel == Pixels.Length || Pixels[nearestPixel].PixelInRing == 1 /*next ring*/)
{
var pixelsInRing = HealpixManager.PixelsCountInRing(Pixels[wasNearestPixel].Ring);
if (wasNearestPixel == nearestPixel)
{
previous += pixelsInRing;
}
else
{
nearestPixel -= pixelsInRing;
}
}
}
}
public void Basin()
{
Data = new BasinData(HealpixManager, false, false
// , -7000d
)
{
NoIntegrationFinish = true,
//Visual = basin => basin.WaterHeight
};
var p = HealpixManager.GetP(HealpixManager.Nside - 1, HealpixManager.Nside * 1);
var basin = Data.PixMan.Pixels[p];
basin.Depth = -500;
basin.hOQ = 10000;
var framesCountBy2 = 300;
Data.Cycle(delegate(int step)
{
Data.Draw(Bmp, 0, null, YResolution, Scale);
SaveBitmap(step);
return(1);
}, framesCountBy2);
}
public BasinDataBase(HealpixManager man, bool withRelief = false, bool spheric = false,
double?min = null, double?max = null, bool readAllAtStart = false)
: base(man, null, min, max, readAllAtStart)
{
Visual = basin => basin.hOQ;
//Visual = basin.Visual * 1000;
ColorsMiddle = 0;
foreach (var basin in PixMan.Pixels)
{
if (withRelief)
{
int waterHeight;
var hOQ = GetHeights(basin, (int)basin.rOfEllipse, out waterHeight);
basin.hOQ = hOQ;
if (waterHeight > 0)
{
basin.Depth = waterHeight - hOQ;
}
else
{
basin.Depth = -hOQ;
}
}
if (spheric)
{
basin.Delta_g_meridian = basin.Delta_g_traverse = 0;
if (withRelief)
{
var diff = Earth2014Manager.Radius2Add - basin.rOfEllipse;
basin.Depth += diff;
basin.hOQ -= diff;
}
basin.InitROfEllipse(HealpixManager, Earth2014Manager.Radius2Add);
}
foreach (Direction to in Enum.GetValues(typeof(Direction)))
{
var toBasin = PixMan.Pixels[man.Neibors.Get(to, basin)];
basin.Neibors[to] = toBasin;
basin.froms[(int)to] = basin.GetFromAndFillType(to, toBasin, HealpixManager);
basin.MeanEdges[(int)to] = man.Neibors.MeanBoundary(basin, to);
}
//basin.CorrectionSurface();
for (int to = 0; to < 4; to++)
{
var toBasin = basin.Neibors[to];
basin.InitialHto[to] = basin.Metric(toBasin, to, true);
}
}
if (withRelief)
{
CheckOcean();
}
}
public void GetP_0()
{
var man = new HealpixManager(0);
Assert.AreEqual(1, man.GetP(1, 2));
Assert.AreEqual(5, man.GetP(2, 2));
Assert.AreEqual(10, man.GetP(3, 3));
}
internal MeridianWater(HealpixManager man, T[] basins, bool symmetricPoles = true) : base(man, basins)
{
_symmetricPoles = symmetricPoles;
foreach (var basin in basins)
{
MaxRing = Math.Max(MaxRing, basin.Ring);
}
}
protected DataEarth2014(HealpixManager man, double?min = null, double?max = null, bool readAllAtStart = false)
{
HealpixManager = man;
MinDefault = min;
MaxDefault = max;
Relief = new Earth2014Manager(ReliefType, Accuracy, IsReliefShape, readAllAtStart);
ReliefBed = new Earth2014Manager(ReliefBedType, Accuracy, IsReliefBedShape, readAllAtStart);
}
internal override void PreInit(HealpixManager man)
{
base.PreInit(man);
NormalCalm = new UnitVector3D(new UnitVector3D(-1, 0, 0) * Matrix.Transpose());
KQQaxisTanCotan_traverse = CalcKQQaxisTanCotan_traverse(GetKQQaxis_traverse());
}
private static void TestAll(HealpixManager man)
{
for (int p = 0; p < man.Npix; p++)
{
Assert.AreEqual(
p,
man.GetCenter <HealCoor>(man.GetCenter <HealCoor>(p).Symmetric(man).P).Symmetric(man).P);
}
}
public void GetCenter_1()
{
var man = new HealpixManager(1);
Assert.AreEqual(135, man.GetCenter(0).X);
Assert.AreEqual(66.44, man.GetCenter(0).Y, .01);
Assert.AreEqual(1, man.GetCenter(0).Ring);
Assert.AreEqual(157.5, man.GetCenter(4).X);
Assert.AreEqual(L41, man.GetCenter(4).Y, .01);
Assert.AreEqual(2, man.GetCenter(4).Ring);
Assert.AreEqual(67.5, man.GetCenter(6).X);
Assert.AreEqual(-22.5, man.GetCenter(8).X, .00001);
Assert.AreEqual(135, man.GetCenter(12).X);
Assert.AreEqual(19.47, man.GetCenter(12).Y, .01);
Assert.AreEqual(3, man.GetCenter(12).Ring);
Assert.AreEqual(90, man.GetCenter(13).X);
Assert.AreEqual(45, man.GetCenter(14).X);
Assert.AreEqual(0, man.GetCenter(15).X);
Assert.AreEqual(-45, man.GetCenter(16).X);
Assert.AreEqual(-135, man.GetCenter(18).X);
Assert.AreEqual(-180, man.GetCenter(19).X);
Assert.AreEqual(157.5, man.GetCenter(20).X);
Assert.AreEqual(0, man.GetCenter(20).Y);
Assert.AreEqual(4, man.GetCenter(20).Ring);
Assert.AreEqual(112.5, man.GetCenter(21).X);
Assert.AreEqual(67.5, man.GetCenter(22).X);
Assert.AreEqual(22.5, man.GetCenter(23).X);
Assert.AreEqual(-22.5, man.GetCenter(24).X, .1);
Assert.AreEqual(-67.5, man.GetCenter(25).X, .1);
Assert.AreEqual(-112.5, man.GetCenter(26).X, .1);
Assert.AreEqual(-157.5, man.GetCenter(27).X, .1);
Assert.AreEqual(4, man.GetCenter(27).Ring);
Assert.AreEqual(135, man.GetCenter(28).X);
Assert.AreEqual(-19.47, man.GetCenter(28).Y, .01);
Assert.AreEqual(5, man.GetCenter(28).Ring);
Assert.AreEqual(45, man.GetCenter(30).X);
Assert.AreEqual(0, man.GetCenter(31).X);
Assert.AreEqual(-180, man.GetCenter(35).X);
Assert.AreEqual(null, man.GetCenter(35).NorthCap);
Assert.AreEqual(false, man.GetCenter(36).NorthCap);
Assert.AreEqual(157.5, man.GetCenter(36).X);
Assert.AreEqual(-L41, man.GetCenter(36).Y, .01);
Assert.AreEqual(6, man.GetCenter(36).Ring);
Assert.AreEqual(112.5, man.GetCenter(37).X);
Assert.AreEqual(22.5, man.GetCenter(39).X);
Assert.AreEqual(-22.5, man.GetCenter(40).X, .0000001);
Assert.AreEqual(-112.5, man.GetCenter(42).X, .00000001);
Assert.AreEqual(-157.5, man.GetCenter(43).X, .00000001);
Assert.AreEqual(135, man.GetCenter(44).X);
Assert.AreEqual(-66.44, man.GetCenter(44).Y, .01);
Assert.AreEqual(7, man.GetCenter(44).Ring);
Assert.AreEqual(45, man.GetCenter(45).X);
Assert.AreEqual(-135, man.GetCenter(47).X);
}
public void GetCenter_2()
{
var man = new HealpixManager(2);
Assert.AreEqual(135, man.GetCenter(0).X);
Assert.AreEqual(22.5, man.GetCenter(7).X);
Assert.AreEqual(3, man.GetCenter(18).Ring);
Assert.AreEqual(15, man.GetCenter(17).X, .0000001);
Assert.AreEqual(-15, man.GetCenter(18).X, .0000001);
Assert.AreEqual(4, man.GetCenter(29).Ring);
Assert.AreEqual(11.25, man.GetCenter(31).X, .0000001);
Assert.AreEqual(-11.25, man.GetCenter(32).X, .0000001);
Assert.AreEqual(5, man.GetCenter(47).Ring);
Assert.AreEqual(0, man.GetCenter(47).X);
Assert.AreEqual(null, man.GetCenter(47).NorthCap);
Assert.AreEqual(11.25, man.GetCenter(63).X, .00001);
Assert.AreEqual(-11.25, man.GetCenter(64).X, .00001);
Assert.AreEqual(0, man.GetCenter(79).X);
Assert.AreEqual(-180, man.GetCenter(87).X);
Assert.AreEqual(168.75, man.GetCenter(88).X);
Assert.AreEqual(0, man.GetCenter(88).Y);
Assert.AreEqual(11.25, man.GetCenter(95).X, .00001);
Assert.AreEqual(-168.75, man.GetCenter(103).X);
Assert.AreEqual(0, man.GetCenter(111).X);
Assert.AreEqual(-180, man.GetCenter(119).X);
Assert.AreEqual(168.75, man.GetCenter(120).X);
Assert.AreEqual(11.25, man.GetCenter(127).X, .00001);
Assert.AreEqual(-11.25, man.GetCenter(128).X, .00001);
Assert.AreEqual(10, man.GetCenter(135).Ring);
Assert.AreEqual(-168.75, man.GetCenter(135).X);
Assert.AreEqual(157.5, man.GetCenter(136).X);
Assert.AreEqual(135, man.GetCenter(137).X);
Assert.AreEqual(0, man.GetCenter(143).X);
Assert.AreEqual(11, man.GetCenter(151).Ring);
Assert.AreEqual(-180, man.GetCenter(151).X);
Assert.AreEqual(false, man.GetCenter(152).NorthCap);
Assert.AreEqual(12, man.GetCenter(152).Ring);
Assert.AreEqual(168.75, man.GetCenter(152).X);
Assert.AreEqual(11.25, man.GetCenter(159).X, .00001);
Assert.AreEqual(-168.75, man.GetCenter(167).X);
Assert.AreEqual(13, man.GetCenter(168).Ring);
Assert.AreEqual(165, man.GetCenter(168).X);
Assert.AreEqual(14, man.GetCenter(187).Ring);
Assert.AreEqual(157.5, man.GetCenter(180).X, .00001);
Assert.AreEqual(-112.5, man.GetCenter(186).X, .00001);
Assert.AreEqual(-157.5, man.GetCenter(187).X, .00001);
Assert.AreEqual(15, man.GetCenter(188).Ring);
Assert.AreEqual(135, man.GetCenter(188).X, .00001);
}
public void SetUp()
{
var man = new HealpixManager(2);
basin0 = man.GetCenter <Basin3>(0);
basin7 = man.GetCenter <Basin3>(7);
basin31 = man.GetCenter <Basin3>(31);
basin77 = man.GetCenter <Basin3>(77);
basin95 = man.GetCenter <Basin3>(95);
}
internal static Coor CoorFromXY(Point2 p, int yResolution, HealpixManager man, int step = 0)
{
var lat = 90d - ((p.Y + BorderWidth) * 180d / (yResolution * man.Nside));
var lon = ((p.X + BorderWidth) * 360 / (4 * man.Nside)) - (180 - step);
var coor = (Coor) new Coor {
Y = lat, X = lon
}.Normalize();
return(coor);
}
internal override void PreInit(HealpixManager man)
{
base.PreInit(man);
LambdaSin = Math.Sin(Lambda.Value);
LambdaMinusPi2Sin = Math.Sin(Lambda.Value - Math.PI / 2);
LambdaCos = Math.Cos(Lambda.Value);
BetaSin = Math.Sin(Beta.Value);
BetaCos = Math.Cos(Beta.Value);
/*
* var thetaTan = Ellipsoid.CalcThetaTan(Beta.Value);
* var varphi = Ellipsoid.CalcVarPhi(thetaTan);
* Theta = Math.PI / 2 - varphi; // faster than Atan(thetaTan) and Atan(thetaTan)<0 when thetaTan>Pi/2
*/
// new
Theta = Beta.Value;
var thetaTan = Math.Tan(Theta);
var varphi = Math.PI / 2 - Theta;
// end of new
InitROfEllipse(man, Ellipsoid.Radius(varphi));
Vartheta = Ellipsoid.CalcVarTheta(thetaTan);
// vertical to ellipsoid surface
var g = EllipsoidAcceleration.GravitationalSomigliana(varphi);
//return g * 100;
double a, aTraverse, aVertical;
var aMeridian = EllipsoidAcceleration.Centrifugal(this, out a, out aTraverse, out aVertical);
// vertical to ellipsoid surface
var aVert = Math.Abs(a * Math.Sin(Vartheta));
// horizontal to ellipsoid surface
//var aHoriz = a * Math.Cos(Vartheta);
// vertical to sphere
gVpure = (g + aVert) * Math.Cos(GoodDeflectionAngle); //Triangles.CalcGPureToCenter
//return gVpure*10000;
// horizontal to sphere
// max: .03299
// horizontal to sphere
var gHor = (g + aVert) * Math.Sin(GoodDeflectionAngle);
//gToCenterByThetaCos = gVpure / Math.Abs(Math.Cos(Theta));
//return basin.GoodDeflectionAngle * 1000;
// vertical to sphere
var aV = a * Math.Sin(Theta);
//return aV * 100;*/
//return aH * 100;
gHpure = gHor - aMeridian;
Delta_g_meridian = GoodDeflectionAngle;
}
public void GetCenter_5()
{
var man = new HealpixManager(5);
for (int p = 24; p < 24 + man.PixelsCountInRing(4); p++)
{
Assert.AreEqual(4, man.GetCenter(p).Ring);
Assert.AreEqual(84.15, man.GetCenter(p).Y, .001);
}
Assert.AreEqual(3, man.GetCenter(18).Ring);
}
private static T[] GetBasins(HealpixManager man)
{
var pix = new List <T>();
T last;
for (var south = man.Npix - 3; south > 0; south = man.Neibors.NorthMean(last))
{
last = man.GetCenter <T>(south);
pix.Add(last);
}
pix.Reverse(); //GetAltitude looks for northbasin
return(pix.ToArray());
}
public void Hto()
{
var man = new HealpixManager(2);
var data = new BasinData(man, false, true);
foreach (var aBasin in data.PixMan.Pixels)
{
Assert.AreEqual(0, aBasin.hOQ);
}
data.GradientAndHeightCrosses();
var basin = data.PixMan.Pixels[(int)(man.Npix * .415)]; // 79 for k2, 20398 for k6
Assert.AreEqual(96, basin.Hto[0] / 1000, 1);
Assert.AreEqual(90, basin.Hto[1] / 1000, 1);
TestNeighbors(basin);
foreach (var aBasin in data.PixMan.Pixels)
{
if (aBasin != basin &&
!(from n in basin.Neibors.Cast <Basin3>()
where n == aBasin
select n).Any())
{
Assert.AreEqual(0, aBasin.hOQ);
}
}
basin = data.PixMan.Pixels[63];
Assert.AreEqual(109, basin.Hto[0] / 1000, 1);
Assert.AreEqual(96, basin.Hto[1] / 1000, 1);
TestNeighbors(basin);
basin = data.PixMan.Pixels[47];
Assert.AreEqual(137, basin.Hto[0] / 1000, 1);
Assert.AreEqual(109, basin.Hto[1] / 1000, 1);
TestNeighbors(basin);
basin = data.PixMan.Pixels[31];
Assert.AreEqual(156, basin.Hto[0] / 1000, 1);
Assert.AreEqual(137, basin.Hto[1] / 1000, 1);
TestNeighbors(basin);
basin = data.PixMan.Pixels[17];
Assert.AreEqual(145, basin.Hto[0] / 1000, 1);
Assert.AreEqual(156, basin.Hto[1] / 1000, 1);
TestNeighbors(basin);
basin = data.PixMan.Pixels[7];
Assert.AreEqual(139, basin.Hto[0] / 1000, 1);
Assert.AreEqual(145, basin.Hto[1] / 1000, 1);
TestNeighbors(basin);
}
internal override void PreInit(HealpixManager man)
{
base.PreInit(man);
Hto = new double[4];
Volumes = new bool[4];
froms = new int[4];
MeanEdges = new Ray3D[4];
InitialHto = new double[4];
//todo why angle with opposite sign?
var rotation = Matrix3D.RotationAroundYAxis(new Angle(-Phi, AngleUnit.Radians))
* Matrix3D.RotationAroundZAxis(new Angle(Lambda.Value, AngleUnit.Radians));
Matrix = rotation.Transpose();
}
public PixelsManager(HealpixManager healpixManager, T[] pix = null)
{
HealpixManager = healpixManager;
if (pix == null)
{
Pixels = new T[healpixManager.Npix];
for (var p = 0; p < healpixManager.Npix; p++)
{
Pixels[p] = healpixManager.GetCenter <T>(p);
}
}
else
{
Pixels = pix;
}
}
/// <returns>typeof Direction</returns>
public int GetFromAndFillType(Direction to, Basin3 toBasin, HealpixManager man)
{
if (Ring == toBasin.Ring)
{
Type = to;
}
var vert = NeighborManager.GetVert(to);
if (Ring == 1 && vert == NeighborVert.North ||
Ring == man.RingsCount && vert == NeighborVert.South ||
Type == to)
{
return((int)NeighborManager.GetOppositeHor(to));
}
return((int)NeighborManager.GetOpposite(to));
}
public void Symmetric()
{
var man = new HealpixManager(0);
var basin = man.GetCenter <HealCoor>(0);
Assert.AreEqual(9, basin.Symmetric(man).P);
Assert.AreEqual(7, man.GetCenter <HealCoor>(5).Symmetric(man).P);
Assert.AreEqual(4, man.GetCenter <HealCoor>(4).Symmetric(man).P);
Assert.AreEqual(5, man.GetCenter <HealCoor>(7).Symmetric(man).P);
Assert.AreEqual(6, man.GetCenter <HealCoor>(6).Symmetric(man).P);
TestAll(man);
TestAll(new HealpixManager(1));
TestAll(new HealpixManager(2));
TestAll(new HealpixManager(3));
TestAll(new HealpixManager(4));
}
public KeyValuePair <int, double>[] GetDeltas(Coor coor)
{
// find nearest 2 rings, may be 1 ring in polar areas
var approximately = (int)((90 - coor.Y) / 180 * Pixels.Length);
// beginning of ring above coor
var nearestFirstRingPixelUp = Math.Max(Math.Min(Pixels.Length - 1, approximately), 0);
nearestFirstRingPixelUp -= Pixels[nearestFirstRingPixelUp].PixelInRing - 1;
while (nearestFirstRingPixelUp > 0 && coor.Y > Pixels[nearestFirstRingPixelUp].Y)
{
nearestFirstRingPixelUp -= HealpixManager.PixelsCountInRing(Pixels[nearestFirstRingPixelUp - 1].Ring);
}
// beginning of ring under coor
var nearestFirstRingPixelDown = Math.Max(0, nearestFirstRingPixelUp);
while (nearestFirstRingPixelDown < Pixels.Length && coor.Y < Pixels[nearestFirstRingPixelDown].Y)
{
nearestFirstRingPixelDown += HealpixManager.PixelsCountInRing(Pixels[nearestFirstRingPixelDown].Ring);
}
var deltas = new Dictionary <int, double>();
if (nearestFirstRingPixelUp >= 0)
{
AddDelta(coor, deltas, nearestFirstRingPixelUp);
}
if (nearestFirstRingPixelDown < Pixels.Length &&
nearestFirstRingPixelDown != nearestFirstRingPixelUp)
{
AddDelta(coor, deltas, nearestFirstRingPixelDown);
}
// approximation-normalization only for 2 closest points
return((from d in deltas orderby d.Value select d).Take(2).ToArray());
}
