Surface Data Types and Customizations

AtomicusChart® processes a variety of surface data types and customizations for data visualization. These surface data types fall into three primary categories:

• Primitives and meshes
• Surface grids
• Raster data

All objects discussed are triangle-based objects, which means they consist of triangle vertexes, triangle list indexes, and normal vectors. Note: Clockwise orientation should be used when triangle indexes are defined.

Triangle-based objects (also referred to as a “triangle mesh”) are used in computer graphics to render data into 2D or, more commonly, 3D. AtomicusChart uses a list of isolated triangles with at least three vertices, known as a triangle list. Triangle lists are then used to visualize an object made up of disjointed pieces, which enables and simplifies further processing of the object. These triangle lists are very useful for creating primitives with sharp edges and shading.

All triangle surface-based data has different customizations for defining the render material for varying ambient, diffusion, and specular intensities as required.

Below is a sample of code for simple mesh generation, which would be used in the examples referenced on this page:

Sample C# code snippet for generation of parametric surface positions:

private Vector3F[] GenSinSurface(int resolution)
{
	var func = new Func<float, float, float>((x, y) => (float)(Math.Sin(x) * Math.Sin(x * x + y * y)));
 
	float rangeMin = -3f, rangeMax = 3f;
	Vector3F[] result = new Vector3F[resolution * resolution];
	int index = 0;
	for (int y = 0; y < resolution; y++)
		for (int x = 0; x < resolution; x++)
		{
			var vx = rangeMin + (rangeMax - rangeMin) * x / (resolution - 1);
			var vy = rangeMin + (rangeMax - rangeMin) * y / (resolution - 1);
			result[index++] = new Vector3F(vx, vy, func(vx, vy));
		}
	return result;
}

Geometry Factory

By calculating a set of geometric attributes, our Geometry Factory helps build geometric objects for the user. All predefined primitives are based on a Geometry Factory.

Sample C# code snippet for creating a mesh using geometry factory:

//Create mesh using geometry factory. For more examples see "AtomicusChart.Interface.GeometryFactory" namespace.
var mesh = AtomicusChart.Interface.GeometryFactory.TorusMeshFactory.GenerateTorus(200, 100, 5, 1);
 
//Simple render data to present mesh.
var primitive = new Surface
{
	SurfaceMesh = mesh,
	Color = Colors.Blue
};
 
// Setup chart options.
chartControl.AxesSettings.Axes3D.IsVisible = true;
chartControl.View.Camera2D.Projection = Projection2DTypes.XPosYPos;
 
// Set data source.
chartControl.DataSource = primitive;

Sample image:

Collection and Composition

In order to improve performance, primitives with the same base mesh can be combined into a collection. Then, separate transformation matrixes can be defined per item, using object picking to identify each item in a collection separately.

Another method of composition involves using composite render data to combine several different objects in order to introduce common properties for the set of objects. Some of these properties include common visibility, name, item in the legend control, and a common transformation matrix.

Sample C# code snippet for creating primitive collection:

const float distToLarge = 0.5f;
const float distToSmall = 1.0f;
const int resolution = 50;
 
var largeCenters = new Vector3F[6];
var smallCenters = new Vector3F[6];
// Create positions.
for (var i = 0; i < 6; i++)
{
	var cos = (float)Math.Cos(Math.PI / 3 * i);
	var sin = (float)Math.Sin(Math.PI / 3 * i);
	largeCenters[i] = new Vector3F(cos * distToLarge, sin * distToLarge, 0);
	smallCenters[i] = new Vector3F(cos * distToSmall, sin * distToSmall, 0);
}
// Show result.
chartControl.DataSource = new CompositeRenderData(new ObservableCollection<RenderData>()
{
	new SphereCollection(largeCenters.Select(Matrix4F.Translation).ToArray(), 0.57f, resolution)
	{
		Color = Colors.Purple,
		IsLegendVisible = false
	},
	new SphereCollection(smallCenters.Select(Matrix4F.Translation).ToArray(), 0.3f, resolution)
	{
		Color = Colors.Gold,
		IsLegendVisible = false
	}
});

Sample image:

Structured Surface Grids

These types of grid maps are displayed as surfaces that are defined by the X, Y, and Z values as positioned in a structured grid, which can be viewed in different projections.

Users can further improve performance by using AtomicusChart data readers to easily update data by regions, from one point to a whole data set. This is very useful for the visualization of a long measurement process or other dynamic data.

Sample C# code snippet for creating a structured grid surface:

const int resolution = 50;
var positions = GenSinSurface(resolution);
var surface = new ValueSurface
{
	// Reader can be reused and we can create several presentations for 1 reader.
	// Note: this reader provider default implementation, so feel free to implement your own logic.
	Reader = new StructuredValueSurfaceDataReader(
		positions, // Define surface points.
		positions.Select(p => p.Z).ToArray(),// Surface values, here they are equal to Z values .
		resolution, resolution,
		new OneAxisBounds(-1, 1, 0, 0.1f)), //Value axis bounds.
											// Setup presentation option.
	PresentationType = ValueSurfacePresentationType.SolidAndWireframe,
	// Set name.
	Name = "Surface"
};
 
// Set data source.
chartControl.DataSource = surface;

Sample image:

Normal mapping: In addition to the techniques mentioned previously, normal data can be added to the raster data. Normal maps use RGB information that corresponds directly with the X, Y, and Z axis in the 3D space. This RGB information identifies the exact direction of each surface normal and how they are oriented in each and every polygon.

Sample C# code snippet for creating a helper class:

private class NormalReader : RasterImage2DReader
{
	private readonly byte[] convertedNormals;
 
	public NormalReader(int resolution, Vector3F[] normals) : base(resolution, resolution, RasterImage2DFormat.Bgr32, false)
	{
		convertedNormals = new byte[normals.Length * 4];
		int index = 0;
		for (int i = 0; i < normals.Length; i++)
		{
			var n = normals[i].GetNormalized();
			if (n.Z > 0)
				n = new Vector3F(-n.X, -n.Y, -n.Z);
			convertedNormals[index++] = (byte)((n.Z + 1) / 2 * 255);
			convertedNormals[index++] = (byte)((n.Y + 1) / 2 * 255);
			convertedNormals[index++] = (byte)((n.X + 1) / 2 * 255);
			convertedNormals[index++] = 0;
		}
	}
 
	public override void InitializeResource(IResourceWriter2D resourceWriter)
	{
		resourceWriter.UpdateResource(convertedNormals, Description.Width * 4);
	}
}

Sample C# code snippet for creating a raster data with normal map:

const int resolution = 200;
// We take the same data as for surfaces for demo purposes, in current case it contains redundant x, y values.
Vector3F[] positions = GenSinSurface(resolution);
 
// Extract only values from z array.
float[] values = positions.Select(v => v.Z).ToArray();
 
var normals = new Vector3F[resolution * resolution];
NormalProcessor.GetSmoothNormals(positions, GridHelper.GetStructuredTriangleListIndices(0, resolution, resolution, 1), normals);
 
// Create geometry.
var geometry = new RectTextureGeometry
{
	Origin = Vector3F.Zero,
	DirectionX = Vector3F.UnitX,
	DirectionY = Vector3F.UnitY,
	Size = new Vector2F(1f, 1f)
};
 
var rasterData = new ValueRasterData
{
	// Linear interpolation.
	InterpolationType = RasterDataInterpolationType.Linear,
	// Float data reader specification (values, data stride/width and value axis bounds).
	Reader = new FloatIntensityImage2DReader(values, resolution, new OneAxisBounds(-1f, 1f, 0, 0.1f)),
	BumpReader = new NormalReader(resolution, normals),
	// Set geometry.
	Geometry = geometry,
	// Set name.
	Name = "Surface"
};
 
// Set chart data source.
chartControl.DataSource = rasterData;

Contours Search With AtomicusChart

A contour line represents a curve along which the function has the same value. Depicting contour lines enables users to obtain more accurate and illustrative information about the analyzed quantity. The density of contour lines shows the rate of change in quantity: More closely spaced contours correspond to a steep variation.

After displaying a number of contours, users can identify regions with the required values of the considered quantity and then analyze those regions separately.

AtomicusChart provides an automatic search for contour lines. Users can specify the number of contours, the quantities at the contours, and their width and color. Users also have the ability to apply a user-defined algorithm for contours search that can be fully integrated into the component infrastructure and connected to its interface.

Sample C# code snippet for countours container:

private class CustomContoursOwner : IContoursOwner
{
	public CustomContoursOwner(ObservableCollection<Contour> contours) => Contours = contours;
 
	public event PropertyChangedEventHandler PropertyChanged;
 
	public event PropertyChangingEventHandler PropertyChanging;
 
	public ObservableCollection<Contour> Contours { get; }
}

Sample C# code snippet for creating contours:

const int resolution = 500;
var positions = GenSinSurface(resolution);
 
// Create contours collection.
var contours = Enumerable.Range(0, 10).Select(i => new Contour(i/5f-1f, Colors.Blue, 2f));
 
// Create the surface data reader.
var reader = new StructuredValueSurfaceDataReader(
	positions, // Define surface points.
	positions.Select(p => p.Z).ToArray(), // Surface values, here they are equal to Z values .
	resolution, resolution,
	new OneAxisBounds(-1, 1, 0, 0.1f)); //Value axis bounds.
 
// Create the surface.
var surface = new ValueSurface
{
	// Reader can be reused and we can create several presentations for 1 reader.
	Reader = reader,
	// Setup presentation option.
	PresentationType = ValueSurfacePresentationType.Solid,
	// Set name.
	Name = "Surface"
};
 
 
// Create the data that is responsible for contour visualization.
var contoursData = new TriangleContoursRenderData
{
	// Set contours computer source.
	DataSource = reader,
	// Set contours collection source.
	ContoursSource = new CustomContoursOwner(new ObservableCollection<Contour>(contours)),
	// Set name.
	Name = "Contours",
};
 
 
// Set data source.
chartControl.DataSource = new RenderData[] { surface, contoursData };

Sample image:

More Features: