public void SkeletonTestB2()
{
var polygon = new List <Vector2d>
{
new Vector2d(0.0, 0.0),
new Vector2d(0.7904833761549828, 8.520486967607015),
new Vector2d(5.9784187896622765, 8.712497973425755),
new Vector2d(5.952691051656153, -2.6355979260182156),
new Vector2d(4.56691002966568, -2.632456164967797),
new Vector2d(4.560358563022897, -5.522203838843264),
new Vector2d(6.0435692076276695, -5.525566487718182),
new Vector2d(6.038049999391761, -7.960001358480875),
new Vector2d(9.886846028339992, -7.968727126560646),
new Vector2d(9.902081573249141, -1.2485706833316517),
new Vector2d(13.74221500483584, -1.2572768087712447),
new Vector2d(13.754007176546189, 3.944062400003698),
new Vector2d(9.194585721122445, 3.9543992526641416),
new Vector2d(9.840828592998651, 10.391220834155359),
new Vector2d(-0.24573045314637643, 10.433085818392197)
};
var expected = new List <Vector2d>
{
new Vector2d(0.311377, 9.026957),
new Vector2d(0.732142, 9.474000),
new Vector2d(6.008508, -4.080606),
new Vector2d(6.810341, 9.573824),
new Vector2d(7.394289, -4.083747),
new Vector2d(7.498680, 2.423725),
new Vector2d(7.813149, 8.564560),
new Vector2d(7.923726, -3.556706),
new Vector2d(7.933442, 0.729015),
new Vector2d(7.966811, -6.039966),
new Vector2d(7.972330, -3.605531),
new Vector2d(8.562422, 1.355149),
new Vector2d(11.147441, 1.349289)
};
expected.AddRange(polygon);
var sk = SkeletonBuilder.Build(polygon);
SkeletonTestUtil.AssertExpectedPoints(expected, SkeletonTestUtil.GetFacePoints(sk));
}
private void BuildSkeleton(Transform root)
{
var position = root.position;
root.position = Vector3.zero;
try
{
// hips -> spine -> chest
var builder = new SkeletonBuilder(root);
builder.AddHips(0.8f, 0.2f);
builder.AddSpine(0.1f);
builder.AddChest(0.2f);
builder.AddNeck(0.1f);
builder.AddHead(0.2f);
builder.AddArm(0.1f, 0.3f, 0.3f, 0.1f);
builder.AddLeg(0.1f, 0.3f, 0.4f, 0.1f, 0.1f);
var description = AvatarDescription.Create(builder.Skeleton);
var animator = GetComponent <Animator>();
animator.avatar = description.CreateAvatar(root);
// create SkinnedMesh for bone visualize
var renderer = SkeletonMeshUtility.CreateRenderer(animator);
if (m_material == null)
{
m_material = new Material(Shader.Find("Standard"));
}
renderer.sharedMaterial = m_material;
//root.gameObject.AddComponent<BoneMapping>();
var transfer = GetComponent <HumanPoseTransfer>();
if (transfer != null)
{
transfer.Avatar = animator.avatar;
transfer.Setup();
}
}
finally
{
// restore position
root.position = position;
}
}
SkeletonBuilder ProcessSkeleton(string name, BinaryMap binary)
{
SkeletonBuilder skeleton = null;
DetailLogger.RunInContext(name, delegate()
{
Logger.Log("Binarized", binary);
BinaryMap thinned = Thinner.Thin(binary);
skeleton = new SkeletonBuilder();
RidgeTracer.Trace(thinned, skeleton);
DotRemover.Filter(skeleton);
PoreRemover.Filter(skeleton);
GapRemover.Filter(skeleton);
TailRemover.Filter(skeleton);
FragmentRemover.Filter(skeleton);
BranchMinutiaRemover.Filter(skeleton);
});
return(skeleton);
}
public void CanGenerateFloorFromFootprint9()
{
_settings.Footprint = new List <Vector2d>()
{
new Vector2d(731.436882019043f, 157.344799041748f),
new Vector2d(720.060272216797f, 171.514301300049f),
new Vector2d(715.286140441895f, 167.680201530457f),
new Vector2d(693.210067749023f, 195.130128860474f),
new Vector2d(697.916450500488f, 198.964233398438f),
new Vector2d(686.742973327637f, 212.911462783813f),
new Vector2d(682.002716064453f, 209.132928848267f),
new Vector2d(671.777305603027f, 221.8577003479f),
new Vector2d(670.152053833008f, 220.635232925415f),
new Vector2d(625.593605041504f, 196.241464614868f),
new Vector2d(627.455825805664f, 197.019395828247f),
new Vector2d(651.055564880371f, 167.569065093994f),
new Vector2d(646.958618164063f, 164.512901306152f),
new Vector2d(663.955841064453f, 141.786131858826f),
new Vector2d(668.79768371582f, 145.397968292236f),
new Vector2d(692.363586425781f, 115.947632789612f),
new Vector2d(719.112205505371f, 132.450933456421f),
new Vector2d(739.867782592773f, 137.007400989532f),
new Vector2d(726.628913879395f, 153.510699272156f),
};
_settings.Doors = null;
_settings.Skeleton = SkeletonBuilder.Build(_settings.Footprint);
_settings.Holes = new List <List <Vector2d> >();
_settings.MinimalWidthStep = 1;
_settings.PreferedWidthStep = 5;
_settings.VaaSizeHeight = 2;
_settings.VaaSizeWidth = 4;
_settings.TransitAreaWidth = 2;
_settings.HalfTransitAreaWidth = 1;
_settings.MinimalArea = 4;
// ACT
var floor = _generator.Build(_settings);
// ASSERT
AssertFloor(floor);
}
SkeletonBuilder ProcessSkeleton(string name, BinaryMap binary)
{
SkeletonBuilder skeleton = null;
DetailLogger.RunInContext(name, delegate()
{
Logger.Log("Binarized", binary);
BinaryMap thinned = Thinner.Thin(binary);
skeleton = new SkeletonBuilder();
RidgeTracer.Trace(thinned, skeleton);
////Testing Start
//var outFileDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "outputSkeletonRidgeTracer-" + name + DateTime.UtcNow.Millisecond + ".bin");
//var file = new FileStream(outFileDir, FileMode.CreateNew);
//var binWrite = new BinaryWriter(file);
//binWrite.Write(skeleton.Minutiae.Count());
//Console.WriteLine(skeleton.Minutiae.Count());
//foreach (var minutia in skeleton.Minutiae)
//{
// binWrite.Write(minutia.Valid);
// Console.WriteLine(minutia.Valid);
// binWrite.Write(minutia.Position.X);
// Console.WriteLine(minutia.Position.X);
// binWrite.Write(minutia.Position.Y);
// Console.WriteLine(minutia.Position.Y);
// binWrite.Write(minutia.Ridges.Count);
// Console.WriteLine(minutia.Ridges.Count);
//}
//binWrite.Close();
//file.Close();
////Testing Finish
DotRemover.Filter(skeleton);
PoreRemover.Filter(skeleton);
GapRemover.Filter(skeleton);
TailRemover.Filter(skeleton);
FragmentRemover.Filter(skeleton);
BranchMinutiaRemover.Filter(skeleton);
});
Count++;
return(skeleton);
}
public void CircularAddTest()
{
var polygon = new List <Vector2d>
{
new Vector2d(50, 50),
new Vector2d(100, 50),
new Vector2d(100, 100),
new Vector2d(50, 100)
};
var expected = new List <Vector2d> {
new Vector2d(75.000000, 75.000000)
};
expected.AddRange(polygon);
var sk = SkeletonBuilder.Build(polygon);
SkeletonTestUtil.AssertExpectedPoints(expected, SkeletonTestUtil.GetFacePoints(sk));
}
public void SkeletonTest_hole_2()
{
var polygon = new List <Vector2d>
{
new Vector2d(0.0, 0.0),
new Vector2d(7.087653026630875, -0.0572739636795121),
new Vector2d(7.035244566479503, -6.5428208800475005),
new Vector2d(-0.052408459722688594, -6.485546915224834)
};
var hole = new List <Vector2d>
{
new Vector2d(1.4849939588531493, -1.5250224044562133),
new Vector2d(1.4341762422598874, -5.1814705083480606),
new Vector2d(5.747532319228888, -5.241418004618678),
new Vector2d(5.798350035536362, -1.5849699030131408)
};
var innerList = new List <List <Vector2d> > {
hole
};
var expected = new List <Vector2d>();
expected.AddRange(polygon);
expected.AddRange(hole);
expected.Add(new Vector2d(6.3821371859978875, -5.893911100019249));
expected.Add(new Vector2d(0.7651208111455217, -5.8321836510415475));
expected.Add(new Vector2d(0.6898242249025952, -5.755213752675646));
expected.Add(new Vector2d(6.389576876981116, -5.886633146615758));
expected.Add(new Vector2d(6.443747494495353, -0.9572661447277495));
expected.Add(new Vector2d(6.310953658294117, -0.8215212379272131));
expected.Add(new Vector2d(0.7481994722534444, -0.7603900949775717));
expected.Add(new Vector2d(0.7446762937827887, -0.7638366801629576));
var sk = SkeletonBuilder.Build(polygon, innerList);
SkeletonTestUtil.AssertExpectedPoints(expected, SkeletonTestUtil.GetFacePoints(sk));
}
public void Skeleton_pickEvent()
{
var outer = new List <Vector2d>
{
new Vector2d(-1, -1),
new Vector2d(1, -1),
new Vector2d(1, 1),
new Vector2d(-1, 1)
};
var expected = new List <Vector2d>
{
new Vector2d(0, 0)
};
expected.AddRange(outer);
var sk = SkeletonBuilder.Build(outer, null);
SkeletonTestUtil.AssertExpectedPoints(expected, SkeletonTestUtil.GetFacePoints(sk));
}
/// <summary>
/// Build the node tree of the robot from Inventor
/// </summary>
public bool LoadRobotSkeleton(Progress <ProgressUpdate> progress = null)
{
try
{
RobotBaseNode = SkeletonBuilder.ExportSkeleton(progress);
GC.Collect();
}
catch (InvalidComObjectException) // TODO: Don't do this
{
}
catch (TaskCanceledException)
{
return(false);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
return(false);
}
return(RobotBaseNode != null);
}
/// <summary>
/// Returns a List of Polygons derived from the Polygon's straight skeleton.
/// </summary>
/// <returns>A List of Polygons.</Line></returns>
public static List <Polygon> Jigsaw(this Polygon polygon)
{
var vertices2d = new List <Vector2d>();
foreach (var vertex in polygon.Vertices)
{
vertices2d.Add(new Vector2d(vertex.X, vertex.Y));
}
var skeleton = SkeletonBuilder.Build(vertices2d);
var polygons = new List <Polygon>();
foreach (var edgeResult in skeleton.Edges)
{
var vertices = new List <Vector3>();
foreach (var vertex in edgeResult.Polygon)
{
vertices.Add(new Vector3(vertex.X, vertex.Y, 0.0));
}
polygons.Add(Shaper.MakePolygon(vertices));
}
return(polygons.OrderBy(p => p.Centroid()).ToList());
}
public void SkeletonTest_hole_1()
{
var inner = new List <Vector2d>
{
new Vector2d(-1, 1),
new Vector2d(1, 1),
new Vector2d(1, -1),
new Vector2d(-1, -1)
};
var outer = new List <Vector2d>
{
new Vector2d(-2, -2),
new Vector2d(2, -2),
new Vector2d(2, 2),
new Vector2d(-2, 2)
};
var innerList = new List <List <Vector2d> > {
inner
};
var expected = new List <Vector2d>
{
new Vector2d(-1.500000, -1.500000),
new Vector2d(-1.500000, 1.500000),
new Vector2d(1.500000, -1.500000),
new Vector2d(1.500000, 1.500000)
};
expected.AddRange(outer);
expected.AddRange(inner);
var sk = SkeletonBuilder.Build(outer, innerList);
SkeletonTestUtil.AssertExpectedPoints(expected, SkeletonTestUtil.GetFacePoints(sk));
}
public static IEnumerable <Polyline> GetStraightSkeleton(Polyline polyline)
{
if (!polyline.IsClosed)
{
throw new Exception(" Polyline must be closed.");
}
var polygon = polyline.Select(p => p.ToVector2d()).ToList();
polygon.RemoveAt(polygon.Count - 1);
var skeleton = SkeletonBuilder.Build(polygon);
//var shape = Polyline.CreateStarPolygon(new Circle(Point3d.Origin, 5), 3, 3);
return(skeleton.Edges.Select(e =>
{
var region = new Polyline(e.Polygon.Select(v => v.ToPoint3d()));
region.Add(region[0]);
// region.AddRange(shape);
return region;
}
));
}
public void SkeletonTestB10()
{
var polygon = new List <Vector2d>
{
new Vector2d(0.0, 0.0),
new Vector2d(23.542862199718826, -1.0957017437087124),
new Vector2d(12.89581137652037, 1.5573908447103584),
new Vector2d(13.68678342709616, 5.195862274901293),
new Vector2d(30.92997412599037, 6.619611963708646),
new Vector2d(16.53428280871175, 7.568778425199767),
new Vector2d(13.05400578686415, 8.676139297892002),
new Vector2d(-4.188927083681472, 7.336703572978552),
new Vector2d(10.196014852102863, 4.475707108744242),
new Vector2d(8.782756714583655, 1.5573908412810287)
};
var expected = new List <Vector2d>
{
new Vector2d(9.496922, 0.613365),
new Vector2d(10.882442, 1.437594),
new Vector2d(11.471020, 0.671521),
new Vector2d(11.720280, 6.390569),
new Vector2d(12.241556, 6.845124),
new Vector2d(12.291810, 5.518617),
new Vector2d(12.847638, 6.893686),
new Vector2d(16.331903, 6.498860)
};
expected.AddRange(polygon);
var sk = SkeletonBuilder.Build(polygon);
SkeletonTestUtil.AssertExpectedPoints(expected, SkeletonTestUtil.GetFacePoints(sk));
}
void Initialize()
{
var skeletonBuilder = new SkeletonBuilder(this.transform);
skeletonBuilder.AddBasicSkeleton(new SkeletonBuilderParams());
var leftHandRotation = Quaternion.Euler(0, 0, 180);
skeletonBuilder.UpdateRotation(HumanBodyBones.LeftHand, leftHandRotation);
var rightHandRotation = Quaternion.Euler(0, 180, 0);
skeletonBuilder.UpdateRotation(HumanBodyBones.RightHand, rightHandRotation);
_LeftHandOVRSkelton = _LeftOVRHand.GetComponent <OVRSkeleton>();
AddHandSkeletonBones(skeletonBuilder, true);
_RightHandOVRSkelton = _RightOVRHand.GetComponent <OVRSkeleton>();
AddHandSkeletonBones(skeletonBuilder, false);
_Skeleton = skeletonBuilder.Skeleton;
var avatar = AvatarBuilder.BuildHumanAvatar(this.gameObject, skeletonBuilder.GetHumanDescription());
_SrcPoseHandler = new HumanPoseHandler(avatar, this.transform);
if (_VisualizeBones && _XYZAxisPrefab != null)
{
foreach (var bone in skeletonBuilder.Skeleton.Values)
{
GameObject axis = GameObject.Instantiate(_XYZAxisPrefab, Vector3.zero, Quaternion.identity, bone);
axis.transform.localScale = new Vector3(_AxisObjectScale, _AxisObjectScale, _AxisObjectScale);
axis.transform.localPosition = Vector3.zero;
axis.transform.localRotation = Quaternion.identity;
}
}
}
public void CanGenerateFloorFromFootprint7()
{
_settings.Footprint = new List <Vector2d>()
{
new Vector2d(299, 133),
new Vector2d(99, 283),
new Vector2d(227, 554),
new Vector2d(832, 575),
new Vector2d(971, 250),
new Vector2d(792, 61),
};
_settings.Doors = new List <KeyValuePair <int, double> >()
{
new KeyValuePair <int, double>(1, 30)
};
_settings.Skeleton = SkeletonBuilder.Build(_settings.Footprint);
_settings.Holes = new List <List <Vector2d> >();
// ACT
var floor = _generator.Build(_settings);
// ASSERT
AssertFloor(floor);
}
public void CanGenerateFloorFromFootprint8()
{
_settings.Footprint = new List <Vector2d>()
{
new Vector2d(107, 62),
new Vector2d(284, 62),
new Vector2d(291, 322),
new Vector2d(464, 320),
new Vector2d(464, 168),
new Vector2d(616, 162),
new Vector2d(618, 309),
new Vector2d(814, 308),
new Vector2d(808, 40),
new Vector2d(1003, 36),
new Vector2d(1003, 495),
new Vector2d(833, 503),
new Vector2d(837, 599),
new Vector2d(616, 604),
new Vector2d(618, 511),
new Vector2d(483, 509),
new Vector2d(480, 600),
new Vector2d(103, 601),
};
_settings.Doors = new List <KeyValuePair <int, double> >()
{
new KeyValuePair <int, double>(1, 30)
};
_settings.Skeleton = SkeletonBuilder.Build(_settings.Footprint);
_settings.Holes = new List <List <Vector2d> >();
// ACT
var floor = _generator.Build(_settings);
// ASSERT
AssertFloor(floor);
}
public void CanGenerateFloorFromFootprint2()
{
// ARRANGE
_settings.Footprint = new List <Vector2d>()
{
new Vector2d(100, 80),
new Vector2d(100, 400),
new Vector2d(500, 400),
new Vector2d(500, 250),
new Vector2d(500, 100),
};
_settings.Doors = new List <KeyValuePair <int, double> >()
{
new KeyValuePair <int, double>(1, 30)
};
_settings.Skeleton = SkeletonBuilder.Build(_settings.Footprint);
_settings.Holes = new List <List <Vector2d> >();
// ACT
var floor = _generator.Build(_settings);
// ASSERT
AssertFloor(floor, 5, 4, 9, 15);
}
public void SkeletonTest_double_split()
{
var outer = new List <Vector2d>
{
new Vector2d(-6, 0),
new Vector2d(-3, -6),
new Vector2d(-1, -2),
new Vector2d(1, -2),
new Vector2d(3, -6),
new Vector2d(6, 0)
};
var expected = new List <Vector2d>(outer)
{
new Vector2d(-3.0000000000000004, -1.854101966249685),
new Vector2d(-1.6180339887498951, -1.0000000000000002),
new Vector2d(1.6180339887498951, -1.0000000000000002),
new Vector2d(3.0000000000000004, -1.854101966249685)
};
var sk = SkeletonBuilder.Build(outer, null);
SkeletonTestUtil.AssertExpectedPoints(expected, SkeletonTestUtil.GetFacePoints(sk));
}
public TemplateBuilder Extract(byte[,] invertedImage, int dpi)
{
TemplateBuilder template = null;
DpiAdjuster.Adjust(this, dpi, delegate()
{
byte[,] image = ImageInverter.GetInverted(invertedImage); //图片反色，黑《--》白
//var watch = Stopwatch.StartNew();
//watch.Start();
BlockMap blocks = new BlockMap(new Size(image.GetLength(1), image.GetLength(0)), BlockSize); //将图片数组转换为blockmap,对图片进行分块，方便进行并行计算
Logger.Log("BlockMap", blocks); //可能是用于调试时的log输出
//watch.Start();
short[, ,] histogram = Histogram.Analyze(blocks, image);
//watch.Stop();
//Console.WriteLine("---------------------------histogram实例化时间：{0}",watch.ElapsedMilliseconds);
//watch.Start();
short[, ,] smoothHistogram = Histogram.SmoothAroundCorners(blocks, histogram);
BinaryMap mask = Mask.ComputeMask(blocks, histogram);
float[,] equalized = Equalizer.Equalize(blocks, image, smoothHistogram, mask);
//watch.Stop();
//Console.WriteLine("----------------------------equalized实例化时间：{0}",watch.ElapsedMilliseconds);
byte[,] orientation = Orientation.Detect(equalized, mask, blocks);
equalizedMap = GdiIO.GetBitmap(ShowImage.floatToByte(equalized));
float[,] smoothed = RidgeSmoother.Smooth(equalized, orientation, mask, blocks);
float[,] orthogonal = OrthogonalSmoother.Smooth(smoothed, orientation, mask, blocks);
BinaryMap binary = Binarizer.Binarize(smoothed, orthogonal, mask, blocks);
binary.AndNot(BinarySmoother.Filter(binary.GetInverted()));
binary.Or(BinarySmoother.Filter(binary));
Logger.Log("BinarySmoothingResult", binary);
CrossRemover.Remove(binary);
BinaryMap pixelMask = mask.FillBlocks(blocks);
BinaryMap innerMask = InnerMask.Compute(pixelMask);
BinaryMap inverted = binary.GetInverted();
inverted.And(pixelMask);
SkeletonBuilder ridges = null;
SkeletonBuilder valleys = null;
Parallel.Invoke(
() => { ridges = ProcessSkeleton("Ridges", binary); },
() => { valleys = ProcessSkeleton("Valleys", inverted); });
template = new TemplateBuilder();
template.OriginalDpi = dpi;
template.OriginalWidth = invertedImage.GetLength(1);
template.OriginalHeight = invertedImage.GetLength(0);
MinutiaCollector.Collect(ridges, TemplateBuilder.MinutiaType.Ending, template);
MinutiaCollector.Collect(valleys, TemplateBuilder.MinutiaType.Bifurcation, template);
MinutiaMask.Filter(template, innerMask);
StandardDpiScaling.Scale(template);
MinutiaCloudRemover.Filter(template);
UniqueMinutiaSorter.Filter(template);
MinutiaSorter.Shuffle(template);
Logger.Log("FinalTemplate", template);
//watch.Stop();
//Console.WriteLine("---------------------------Template实例化时间：{0}",watch.ElapsedMilliseconds);
});
return(template);
}
/// <inheritdoc />
public override List <MeshData> Build(Building building)
{
var roofHeight = building.RoofHeight;
var roofOffset = building.Elevation + building.MinHeight + building.Height;
var skeleton = SkeletonBuilder.Build(building.Footprint);
var roofVertexCount = 0;
foreach (var edgeResult in skeleton.Edges)
{
roofVertexCount += (edgeResult.Polygon.Count - 2) * 12;
}
var mesh = CreateMesh(building.Footprint);
var floorCount = building.Levels;
var floorVertexCount = mesh.Triangles.Count * 3 * 2 * floorCount;
var vertexCount = roofVertexCount + floorVertexCount;
var planeCount = skeleton.Edges.Count + floorCount;
bool limitIsReached = false;
if (vertexCount * 2 > Consts.MaxMeshSize)
{
vertexCount = roofVertexCount;
planeCount = building.Footprint.Count;
limitIsReached = true;
}
var meshIndex = new MultiPlaneMeshIndex(planeCount + floorCount, vertexCount);
MeshData meshData = new MeshData(meshIndex, vertexCount);
try
{
var roofGradient = CustomizationService.GetGradient(building.RoofColor);
foreach (var edge in skeleton.Edges)
{
if (edge.Polygon.Count < 5)
{
HandleSimpleCase(meshData, meshIndex, roofGradient, skeleton, edge, roofOffset, roofHeight);
}
else
{
HandleComplexCase(meshData, meshIndex, roofGradient, skeleton, edge, roofOffset, roofHeight);
}
}
if (!limitIsReached)
{
// attach floors
AttachFloors(new RoofContext()
{
Mesh = mesh,
MeshData = meshData,
MeshIndex = meshIndex,
Bottom = building.Elevation + building.MinHeight,
FloorCount = floorCount,
FloorHeight = building.Height / floorCount,
FloorFrontGradient = CustomizationService.GetGradient(building.FloorFrontColor),
FloorBackGradient = CustomizationService.GetGradient(building.FloorBackColor),
IsLastRoof = false
});
return(new List <MeshData>(1)
{
meshData
});
}
var meshDataList = BuildFloors(building, building.Levels, false);
meshDataList.Add(meshData);
return(meshDataList);
}
catch
{
// NOTE straight skeleton may fail on some footprints.
Trace.Warn("building.roof", Strings.RoofGenFailed, Name, building.Id.ToString());
return(base.Build(building));
}
}
public TemplateBuilder Extract(byte[,] invertedImage, int dpi)
{
TemplateBuilder template = null;
DpiAdjuster.Adjust(this, dpi, delegate()
{
byte[,] image = ImageInverter.GetInverted(invertedImage);
BlockMap blocks = new BlockMap(new Size(image.GetLength(1), image.GetLength(0)), BlockSize);
Logger.Log("BlockMap", blocks);
//Testing Start
var outFileDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "bloackMapOut" + DateTime.Now.Second + ".bin");
var outFileText = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"blockMapTextOut" + DateTime.Now.Second + ".txt");
var file = new FileStream(outFileDir, FileMode.CreateNew);
var binWrite = new BinaryWriter(file);
TextWriter tw = new StreamWriter(outFileText);
LogSize(blocks.PixelCount, binWrite, tw, "PixelCount");
LogSize(blocks.BlockCount, binWrite, tw, "BlockCount");
LogSize(blocks.CornerCount, binWrite, tw, "CornerCount");
LogRectangleC(blocks.AllBlocks, binWrite, tw, "AllBlocks");
LogRectangleC(blocks.AllCorners, binWrite, tw, "AllCorners");
LogPointGrid(blocks.Corners, binWrite, tw, "Corners");
LogRectangleGrid(blocks.BlockAreas, binWrite, tw, "BlockAreas");
LogPointGrid(blocks.BlockCenters, binWrite, tw, "BlockCenters");
LogRectangleGrid(blocks.CornerAreas, binWrite, tw, "CornerAreas");
binWrite.Close();
tw.Close();
//Testing End
short[,,] histogram = Histogram.Analyze(blocks, image);
////testing
//var outFileDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "histogramImageInput" + ".bin");
//var file = new FileStream(outFileDir, FileMode.CreateNew);
//var binWrite = new BinaryWriter(file);
//binWrite.Write(image.GetLength(0));
//binWrite.Write(image.GetLength(1));
//for (var i = 0; i < image.GetLength(0); i++)
//{
// for (var j = 0; j < image.GetLength(1); j++)
// {
// binWrite.Write(image[i, j]);
// }
//}
//binWrite.Close();
////End testing
////Testing Start
//Count++;
//var outFileDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "histogramOut" + Count + ".bin");
//var outFileText = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
// "histogramTextOut" + Count + ".txt");
//var file = new FileStream(outFileDir, FileMode.CreateNew);
//var binWrite = new BinaryWriter(file);
//TextWriter tw = new StreamWriter(outFileText);
//binWrite.Write(histogram.GetLength(0));
//tw.WriteLine(histogram.GetLength(0));
//binWrite.Write(histogram.GetLength(1));
//tw.WriteLine(histogram.GetLength(1));
//binWrite.Write(histogram.GetLength(2));
//tw.WriteLine(histogram.GetLength(2));
//for (var i = 0; i < histogram.GetLength(0); i++)
//{
// for (var j = 0; j < histogram.GetLength(1); j++)
// {
// for (var k = 0; k < histogram.GetLength(2); k++)
// {
// binWrite.Write(histogram[i, j, k]);
// tw.WriteLine(histogram[i, j, k]);
// }
// }
//}
//binWrite.Close();
//file.Close();
//tw.Close();
//Testing Finish
//Testing Start
//outFileDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "bloackMapOutPostHis" + DateTime.Now.Second + ".bin");
//outFileText = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
// "blockMapTextOutPostHis" + DateTime.Now.Second + ".txt");
//file = new FileStream(outFileDir, FileMode.CreateNew);
//binWrite = new BinaryWriter(file);
//tw = new StreamWriter(outFileText);
//LogSize(blocks.PixelCount, binWrite, tw);
//LogSize(blocks.BlockCount, binWrite, tw);
//LogSize(blocks.CornerCount, binWrite, tw);
//LogRectangleC(blocks.AllBlocks, binWrite, tw);
//LogRectangleC(blocks.AllCorners, binWrite, tw);
//LogPointGrid(blocks.Corners, binWrite, tw);
//LogRectangleGrid(blocks.BlockAreas, binWrite, tw);
//LogPointGrid(blocks.BlockCenters, binWrite, tw);
//LogRectangleGrid(blocks.CornerAreas, binWrite, tw);
//binWrite.Close();
//tw.Close();
//Testing End
short[,,] smoothHistogram = Histogram.SmoothAroundCorners(blocks, histogram);
BinaryMap mask = Mask.ComputeMask(blocks, histogram);
float[,] equalized = Equalizer.Equalize(blocks, image, smoothHistogram, mask);
byte[,] orientation = Orientation.Detect(equalized, mask, blocks);
float[,] smoothed = RidgeSmoother.Smooth(equalized, orientation, mask, blocks);
float[,] orthogonal = OrthogonalSmoother.Smooth(smoothed, orientation, mask, blocks);
BinaryMap binary = Binarizer.Binarize(smoothed, orthogonal, mask, blocks);
binary.AndNot(BinarySmoother.Filter(binary.GetInverted()));
binary.Or(BinarySmoother.Filter(binary));
Logger.Log("BinarySmoothingResult", binary);
CrossRemover.Remove(binary);
BinaryMap pixelMask = mask.FillBlocks(blocks);
BinaryMap innerMask = InnerMask.Compute(pixelMask);
BinaryMap inverted = binary.GetInverted();
inverted.And(pixelMask);
SkeletonBuilder ridges = null;
SkeletonBuilder valleys = null;
Parallel.Invoke(
() => { ridges = ProcessSkeleton("Ridges", binary); },
() => { valleys = ProcessSkeleton("Valleys", inverted); });
template = new TemplateBuilder();
template.OriginalDpi = dpi;
template.OriginalWidth = invertedImage.GetLength(1);
template.OriginalHeight = invertedImage.GetLength(0);
MinutiaCollector.Collect(ridges, TemplateBuilder.MinutiaType.Ending, template);
MinutiaCollector.Collect(valleys, TemplateBuilder.MinutiaType.Bifurcation, template);
MinutiaMask.Filter(template, innerMask);
StandardDpiScaling.Scale(template);
MinutiaCloudRemover.Filter(template);
UniqueMinutiaSorter.Filter(template);
MinutiaSorter.Shuffle(template);
Logger.Log("FinalTemplate", template);
});
return(template);
}
