public void OrganizedExtractionTest()
{
using (var cloud = new PointCloudOfXYZ())
using (var clusterIndices = new VectorOfPointIndices())
{
using (var reader = new PCDReader())
reader.Read(DataPath("tutorials/table_scene_mug_stereo_textured.pcd"), cloud);
int organizedClusterCount;
using (var ec = new EuclideanClusterExtractionOfXYZ
{
ClusterTolerance = 0.01,
MinClusterSize = 100,
MaxClusterSize = 800000
})
{
using (var organized = new Search.OrganizedNeighborOfXYZ())
using (var tree = new Search.KdTreeOfXYZ())
{
organized.SetInputCloud(cloud);
ec.SetSearchMethod(organized);
ec.Extract(clusterIndices);
organizedClusterCount = clusterIndices.Count;
clusterIndices.Clear();
ec.SetSearchMethod(tree);
ec.Extract(clusterIndices);
Assert.AreEqual(clusterIndices.Count, organizedClusterCount, "organized neighbor cluster count did not match kdtree cluster count");
}
}
}
}
public void FileReadPointsTest()
{
PCDReader <PointXYZ> reader = new PCDReader <PointXYZ>();
PCDHeader header = reader.ReadHeader("test.pcd");
Assert.AreEqual(213, header.Points);
}
public void FileReadVersionTest()
{
PCDReader <PointXYZ> reader = new PCDReader <PointXYZ>();
PCDHeader header = reader.ReadHeader("test.pcd");
Assert.AreEqual(PCDVersion.PCDv7, header.Version);
}
public void FileReadPointsTest()
{
PCDReader<PointXYZ> reader = new PCDReader<PointXYZ>();
PCDHeader header = reader.ReadHeader("test.pcd");
Assert.AreEqual(213, header.Points);
}
public void FileReadHeightTest()
{
PCDReader<PointXYZ> reader = new PCDReader<PointXYZ>();
PCDHeader header = reader.ReadHeader("test.pcd");
Assert.AreEqual(1, header.Height);
}
public void FileReadHeightTest()
{
PCDReader <PointXYZ> reader = new PCDReader <PointXYZ>();
PCDHeader header = reader.ReadHeader("test.pcd");
Assert.AreEqual(1, header.Height);
}
public void FileReadCompleteTest()
{
PCDReader<PointXYZ> reader = new PCDReader<PointXYZ>();
PointCloud<PointXYZ> cloud = reader.Read("test.pcd");
Assert.AreEqual(213, cloud.Points.Count);
Assert.AreEqual(0.93773, cloud[0].X, 0.000001);
Assert.AreEqual(0.33763, cloud[0].Y, 0.000001);
Assert.AreEqual(0, cloud[0].Z, 0.000001);
}
public void FileReadCompleteTest()
{
PCDReader <PointXYZ> reader = new PCDReader <PointXYZ>();
PointCloud <PointXYZ> cloud = reader.Read("test.pcd");
Assert.AreEqual(213, cloud.Points.Count);
Assert.AreEqual(0.93773, cloud[0].X, 0.000001);
Assert.AreEqual(0.33763, cloud[0].Y, 0.000001);
Assert.AreEqual(0, cloud[0].Z, 0.000001);
}
public void FileReadFieldsTest()
{
PCDReader<PointXYZ> reader = new PCDReader<PointXYZ>();
PCDHeader header = reader.ReadHeader("test.pcd");
Assert.AreEqual(4, header.Fields.Count);
Assert.AreEqual(4, header.Fields[0].Size);
Assert.AreEqual('F', header.Fields[0].Type);
Assert.AreEqual(1, header.Fields[0].Count);
}
public void FileReadFieldsTest()
{
PCDReader <PointXYZ> reader = new PCDReader <PointXYZ>();
PCDHeader header = reader.ReadHeader("test.pcd");
Assert.AreEqual(4, header.Fields.Count);
Assert.AreEqual(4, header.Fields[0].Size);
Assert.AreEqual('F', header.Fields[0].Type);
Assert.AreEqual(1, header.Fields[0].Count);
}
public void StatisticalOutlierRemovalTutorialTest()
{
using (var cloud = new PointCloudOfXYZ())
using (var cloudFiltered = new PointCloudOfXYZ())
{
using (var reader = new PCDReader())
reader.Read(DataPath("tutorials/table_scene_lms400.pcd"), cloud);
using (var sor = new Filters.StatisticalOutlierRemovalOfXYZ())
{
sor.SetInputCloud(cloud);
sor.MeanK = 50;
sor.StdDevMulThresh = 1;
sor.filter(cloudFiltered);
Assert.IsTrue(cloudFiltered.Count > 0);
Assert.IsTrue(cloudFiltered.Count < cloud.Count);
}
}
}
static void Main(string[] args)
{
using (var cloud = new PointCloudOfXYZRGBA())
{
using (var reader = new PCDReader())
reader.Read(DataPath("tutorials/table_scene_mug_stereo_textured.pcd"), cloud);
using (var visualizer = new Visualizer("a window"))
{
visualizer.AddPointCloud(cloud);
visualizer.SetPointCloudRenderingProperties(RenderingProperties.PointSize, 2);
visualizer.SetPointCloudRenderingProperties(RenderingProperties.Opacity, 0.95);
while (!visualizer.WasStopped)
{
visualizer.SpinOnce(100);
}
}
}
}
public void TestIntegralFile()
{
//copying integral image tutorial from http://pointclouds.org/documentation/tutorials/normal_estimation_using_integral_images.php#normal-estimation-using-integral-images
using (var cloud = new PointCloudOfXYZ())
using (var normals = new PointCloudOfNormal())
using (var ne = new IntegralImageNormalEstimationPointXYZAndNormal())
{
using (var reader = new PCDReader())
if (reader.Read(DataPath("tutorials/table_scene_mug_stereo_textured.pcd"), cloud) < 0)
{
Assert.Fail("could not open pcd file");
}
ne.SetNormalEstimationMethod(IntegralImageNormalEstimation.NormalEstimationMethod.Average3DGradient);
ne.SetMaxDepthChangeFactor(0.02f);
ne.SetNormalSmoothingSize(10f);
ne.SetInputCloud(cloud);
ne.Compute(normals);
Assert.IsTrue(normals.Count == cloud.Count, "normals count did not match cloud count");
}
}
public unsafe void SupervoxelClusteringTutorialTest()
{
var voxelResolution = 0.008f;
var seedResolution = 0.1f;
var colorImportance = 0.2f;
var spatialImportance = 0.4f;
var normalImportance = 1f;
using (var cloud = new PointCloudOfXYZRGBA())
using (var adjacentSupervoxelCenters = new PointCloudOfXYZRGBA())
{
using (var reader = new PCDReader())
//Assert.AreEqual(0, reader.Read(DataPath("tutorials/correspondence_grouping/milk_cartoon_all_small_clorox.pcd"), cloud));
Assert.AreEqual(0, reader.Read(DataPath("tutorials/table_scene_mug_stereo_textured.pcd"), cloud));
var min = new Vector3(float.MaxValue);
var max = new Vector3(float.MinValue);
foreach (var p in cloud.Points)
{
min = Vector3.Min(min, p.V);
max = Vector3.Max(max, p.V);
}
using (var normals = new PointCloudOfNormal(cloud.Width, cloud.Height))
using (var super = new Segmentation.SupervoxelClusteringOfXYZRGBA(voxelResolution, seedResolution))
using (var clusters = new Segmentation.SupervoxelClustersOfXYZRGBA())
{
using (var ne = new IntegralImageNormalEstimationPointXYZAndNormal())
using (var noColor = new PointCloudOfXYZ(cloud.Width, cloud.Height))
{
var count = cloud.Count;
var cptr = cloud.Data;
var nptr = noColor.Data;
for (var i = 0; i < count; i++)
{
(nptr + i)->V = (cptr + i)->V;
}
ne.SetNormalEstimationMethod(IntegralImageNormalEstimation.NormalEstimationMethod.Average3DGradient);
ne.SetMaxDepthChangeFactor(0.02f);
ne.SetNormalSmoothingSize(10f);
ne.SetInputCloud(noColor);
ne.Compute(normals);
}
super.SetInputCloud(cloud);
super.SetNormalCloud(normals);
super.SetColorImportance(colorImportance);
super.SetSpatialImportance(spatialImportance);
super.SetNormalImportance(normalImportance);
super.Extract(clusters);
Assert.IsTrue(clusters.Count > 0);
using (var adjacency = new MultiMapOfuintAnduint())
{
super.GetSupervoxelAdjacency(adjacency);
Assert.AreEqual(350, adjacency.Count);
var i = 0;
foreach (var kvp in adjacency)
{
i++;
}
Assert.AreEqual(350, i);
using (var labelItr = adjacency.Begin())
using (var end = adjacency.End())
{
for (; !labelItr.Equals(end);)
{
var supervoxelLabel = labelItr.Key;
var supervoxel = clusters.At(supervoxelLabel);
foreach (var kvp in adjacency.EqualRange(supervoxelLabel))
{
var neighbor = clusters.At(kvp.Value);
adjacentSupervoxelCenters.Add(neighbor.Centroid);
}
adjacency.UpperBound(supervoxelLabel, labelItr);
}
}
Assert.AreEqual(350, adjacentSupervoxelCenters.Count);
}
}
}
}
public void ClusterExtractionTutorialTest()
{
using (var cloud = new PointCloudOfXYZ())
using (var clusterIndices = new VectorOfPointIndices())
{
using (var reader = new PCDReader())
reader.Read(DataPath("tutorials/table_scene_lms400.pcd"), cloud);
using (var vg = new VoxelGridOfXYZ())
{
vg.SetInputCloud(cloud);
vg.LeafSize = new Vector3(0.01f);
var cloudFiltered = new PointCloudOfXYZ();
vg.filter(cloudFiltered);
using (var seg = new SACSegmentationOfXYZ()
{
OptimizeCoefficients = true,
ModelType = SACModel.Plane,
MethodType = SACMethod.RANSAC,
MaxIterations = 100,
DistanceThreshold = 0.02f
})
using (var cloudPlane = new PointCloudOfXYZ())
using (var coefficients = new Common.ModelCoefficients())
using (var inliers = new PointIndices())
{
int i = 0;
int nrPoints = cloudFiltered.Points.Count;
while (cloudFiltered.Points.Count > 0.3 * nrPoints)
{
seg.SetInputCloud(cloudFiltered);
seg.Segment(inliers, coefficients);
if (inliers.Indices.Count == 0)
{
Assert.Fail("could not estimate a planar model for the given dataset");
}
using (var extract = new ExtractIndicesOfXYZ()
{
Negative = false
})
{
extract.SetInputCloud(cloudFiltered);
extract.SetIndices(inliers.Indices);
extract.filter(cloudPlane);
extract.Negative = true;
var cloudF = new PointCloudOfXYZ();
extract.filter(cloudF);
cloudFiltered.Dispose();
cloudFiltered = cloudF;
}
i++;
}
Assert.IsTrue(i > 1, "Didn't find more than 1 plane");
var tree = new Search.KdTreeOfXYZ();
tree.SetInputCloud(cloudFiltered);
using (var ec = new EuclideanClusterExtractionOfXYZ
{
ClusterTolerance = 0.02,
MinClusterSize = 100,
MaxClusterSize = 25000
})
{
ec.SetSearchMethod(tree);
ec.SetInputCloud(cloudFiltered);
ec.Extract(clusterIndices);
}
foreach (var pis in clusterIndices)
{
using (var cloudCluster = new PointCloudOfXYZ())
{
foreach (var pit in pis.Indices)
{
cloudCluster.Add(cloudFiltered.Points[pit]);
}
cloudCluster.Width = cloudCluster.Points.Count;
cloudCluster.Height = 1;
}
}
}
}
}
}
public void FileReadVersionTest()
{
PCDReader<PointXYZ> reader = new PCDReader<PointXYZ>();
PCDHeader header = reader.ReadHeader("test.pcd");
Assert.AreEqual(PCDVersion.PCDv7, header.Version);
}
private void loadFile()
{
_cloud = PCDReader <PointXYZ> .LoadPCDFile(FileName);
this.RenderWindow.SetPoints(_cloud.Points.Select(x => new Vector3(x.X, x.Y, x.Z)).ToList());
}
