/// <summary>
/// Creates a new AbstractSelectionStep.
/// </summary>
/// <param name="options"></param>
/// <param name="prompt"></param>
/// <param name="renderer">A function to generate a UI control representing the available options.</param>
/// <param name="resultDelegate">A function that returns the options that were selected</param>
/// <param name="preselected">A list of options selected at initialization</param>
public AbstractSelectionStep(RendererDelegate renderer, SelectionResultDelgate resultDelegate,
IEnumerable <ResultType> options, string prompt)
: this(options, prompt)
{
this.Renderer = renderer;
this.ResultDelegate = resultDelegate;
}
private void SetupRenderer()
{
RendererDelegate rDel = GetGlProc;
var ptr = Marshal.GetFunctionPointerForDelegate(rDel);
RegisterRenderer(ptr);
//CreateRenderer();
//Initialize((uint) _window.ClientSize.Width, (uint) _window.ClientSize.Height);
renderer = new X3DRenderer((uint)_window.ClientSize.Width, (uint)_window.ClientSize.Height);
//Quickly test the mesh
mesh = new X3DMesh(renderer);
RustVector3 cam_pos = new RustVector3(0.0f, 0.0f, 0.0f);
cam = new X3DCamera(60f, 0.02f, 100f, 16f, 1f / 100f, 100f, cam_pos);
string vs = FileLoader.GetShader("shaders/vertex.glsl");
string fs = FileLoader.GetShader("shaders/fragment.glsl");
X3DShader shader = new X3DShader(vs, null, null, fs);
material = new X3DMaterial(shader);
}
/// <summary>
/// Contour is a contouring subroutine for rectangularily spaced data
/// It emits calls to a line drawing subroutine supplied by the user
/// which draws a contour map corresponding to data on a randomly
/// spaced rectangular grid. The coordinates emitted are in the same
/// units given in the x() and y() arrays.
/// Any number of contour levels may be specified but they must be
/// in order of increasing value.
/// </summary>
/// <param name="d">Matrix of data to contour.</param>
/// <param name="x">Data matrix column coordinates.</param>
/// <param name="y">Data matrix row coordinates.</param>
/// <param name="z">Contour levels in increasing order.</param>
/// <param name="renderer">The renderer.</param>
public static void Contour(double[,] d, double[] x, double[] y, double[] z, RendererDelegate renderer)
{
double x1 = 0.0;
double x2 = 0.0;
double y1 = 0.0;
double y2 = 0.0;
var h = new double[5];
var sh = new int[5];
var xh = new double[5];
var yh = new double[5];
int ilb = d.GetLowerBound(0);
int iub = d.GetUpperBound(0);
int jlb = d.GetLowerBound(1);
int jub = d.GetUpperBound(1);
int nc = z.Length;
// The indexing of im and jm should be noted as it has to start from zero
// unlike the fortran counter part
int[] im = { 0, 1, 1, 0 };
int[] jm = { 0, 0, 1, 1 };
// Note that castab is arranged differently from the FORTRAN code because
// Fortran and C/C++ arrays are transposed of each other, in this case
// it is more tricky as castab is in 3 dimension
int[,,] castab =
{
{ { 0, 0, 8 }, { 0, 2, 5 }, { 7, 6, 9 } }, { { 0, 3, 4 }, { 1, 3, 1 }, { 4, 3, 0 } },
{ { 9, 6, 7 }, { 5, 2, 0 }, { 8, 0, 0 } }
};
Func <int, int, double> xsect = (p1, p2) => ((h[p2] * xh[p1]) - (h[p1] * xh[p2])) / (h[p2] - h[p1]);
Func <int, int, double> ysect = (p1, p2) => ((h[p2] * yh[p1]) - (h[p1] * yh[p2])) / (h[p2] - h[p1]);
for (int j = jub - 1; j >= jlb; j--)
{
int i;
for (i = ilb; i <= iub - 1; i++)
{
double temp1 = Math.Min(d[i, j], d[i, j + 1]);
double temp2 = Math.Min(d[i + 1, j], d[i + 1, j + 1]);
double dmin = Math.Min(temp1, temp2);
temp1 = Math.Max(d[i, j], d[i, j + 1]);
temp2 = Math.Max(d[i + 1, j], d[i + 1, j + 1]);
double dmax = Math.Max(temp1, temp2);
if (dmax >= z[0] && dmin <= z[nc - 1])
{
int k;
for (k = 0; k < nc; k++)
{
if (z[k] >= dmin && z[k] <= dmax)
{
int m;
for (m = 4; m >= 0; m--)
{
if (m > 0)
{
// The indexing of im and jm should be noted as it has to
// start from zero
h[m] = d[i + im[m - 1], j + jm[m - 1]] - z[k];
xh[m] = x[i + im[m - 1]];
yh[m] = y[j + jm[m - 1]];
}
else
{
h[0] = 0.25 * (h[1] + h[2] + h[3] + h[4]);
xh[0] = 0.5 * (x[i] + x[i + 1]);
yh[0] = 0.5 * (y[j] + y[j + 1]);
}
if (h[m] > 0.0)
{
sh[m] = 1;
}
else if (h[m] < 0.0)
{
sh[m] = -1;
}
else
{
sh[m] = 0;
}
}
//// Note: at this stage the relative heights of the corners and the
//// centre are in the h array, and the corresponding coordinates are
//// in the xh and yh arrays. The centre of the box is indexed by 0
//// and the 4 corners by 1 to 4 as shown below.
//// Each triangle is then indexed by the parameter m, and the 3
//// vertices of each triangle are indexed by parameters m1,m2,and
//// m3.
//// It is assumed that the centre of the box is always vertex 2
//// though this isimportant only when all 3 vertices lie exactly on
//// the same contour level, in which case only the side of the box
//// is drawn.
//// vertex 4 +-------------------+ vertex 3
//// | \ / |
//// | \ m-3 / |
//// | \ / |
//// | \ / |
//// | m=2 X m=2 | the centre is vertex 0
//// | / \ |
//// | / \ |
//// | / m=1 \ |
//// | / \ |
//// vertex 1 +-------------------+ vertex 2
// Scan each triangle in the box
for (m = 1; m <= 4; m++)
{
int m1 = m;
int m2 = 0;
int m3;
if (m != 4)
{
m3 = m + 1;
}
else
{
m3 = 1;
}
int caseValue = castab[sh[m1] + 1, sh[m2] + 1, sh[m3] + 1];
if (caseValue != 0)
{
switch (caseValue)
{
case 1: // Line between vertices 1 and 2
x1 = xh[m1];
y1 = yh[m1];
x2 = xh[m2];
y2 = yh[m2];
break;
case 2: // Line between vertices 2 and 3
x1 = xh[m2];
y1 = yh[m2];
x2 = xh[m3];
y2 = yh[m3];
break;
case 3: // Line between vertices 3 and 1
x1 = xh[m3];
y1 = yh[m3];
x2 = xh[m1];
y2 = yh[m1];
break;
case 4: // Line between vertex 1 and side 2-3
x1 = xh[m1];
y1 = yh[m1];
x2 = xsect(m2, m3);
y2 = ysect(m2, m3);
break;
case 5: // Line between vertex 2 and side 3-1
x1 = xh[m2];
y1 = yh[m2];
x2 = xsect(m3, m1);
y2 = ysect(m3, m1);
break;
case 6: // Line between vertex 3 and side 1-2
x1 = xh[m3];
y1 = yh[m3];
x2 = xsect(m1, m2);
y2 = ysect(m1, m2);
break;
case 7: // Line between sides 1-2 and 2-3
x1 = xsect(m1, m2);
y1 = ysect(m1, m2);
x2 = xsect(m2, m3);
y2 = ysect(m2, m3);
break;
case 8: // Line between sides 2-3 and 3-1
x1 = xsect(m2, m3);
y1 = ysect(m2, m3);
x2 = xsect(m3, m1);
y2 = ysect(m3, m1);
break;
case 9: // Line between sides 3-1 and 1-2
x1 = xsect(m3, m1);
y1 = ysect(m3, m1);
x2 = xsect(m1, m2);
y2 = ysect(m1, m2);
break;
}
renderer(x1, y1, x2, y2, z[k]);
}
}
}
}
}
}
}
}
/// <summary>
/// Contour is a contouring subroutine for rectangularily spaced data
/// It emits calls to a line drawing subroutine supplied by the user
/// which draws a contour map corresponding to data on a randomly
/// spaced rectangular grid. The coordinates emitted are in the same
/// units given in the x() and y() arrays.
/// Any number of contour levels may be specified but they must be
/// in order of increasing value.
/// </summary>
/// <param name="d">
/// Matrix of data to contour.
/// </param>
/// <param name="x">
/// Data matrix column coordinates.
/// </param>
/// <param name="y">
/// Data matrix row coordinates.
/// </param>
/// <param name="z">
/// Contour levels in increasing order.
/// </param>
/// <param name="renderer">
/// The renderer.
/// </param>
public static void Contour(double[,] d, double[] x, double[] y, double[] z, RendererDelegate renderer)
{
double x1 = 0.0;
double x2 = 0.0;
double y1 = 0.0;
double y2 = 0.0;
var h = new double[5];
var sh = new int[5];
var xh = new double[5];
var yh = new double[5];
int ilb = d.GetLowerBound(0);
int iub = d.GetUpperBound(0);
int jlb = d.GetLowerBound(1);
int jub = d.GetUpperBound(1);
int nc = z.Length;
// The indexing of im and jm should be noted as it has to start from zero
// unlike the fortran counter part
int[] im = { 0, 1, 1, 0 };
int[] jm = { 0, 0, 1, 1 };
// Note that castab is arranged differently from the FORTRAN code because
// Fortran and C/C++ arrays are transposed of each other, in this case
// it is more tricky as castab is in 3 dimension
int[,,] castab =
{
{ { 0, 0, 8 }, { 0, 2, 5 }, { 7, 6, 9 } }, { { 0, 3, 4 }, { 1, 3, 1 }, { 4, 3, 0 } },
{ { 9, 6, 7 }, { 5, 2, 0 }, { 8, 0, 0 } }
};
Func<int, int, double> xsect = (p1, p2) => ((h[p2] * xh[p1]) - (h[p1] * xh[p2])) / (h[p2] - h[p1]);
Func<int, int, double> ysect = (p1, p2) => ((h[p2] * yh[p1]) - (h[p1] * yh[p2])) / (h[p2] - h[p1]);
for (int j = jub - 1; j >= jlb; j--)
{
int i;
for (i = ilb; i <= iub - 1; i++)
{
double temp1 = Math.Min(d[i, j], d[i, j + 1]);
double temp2 = Math.Min(d[i + 1, j], d[i + 1, j + 1]);
double dmin = Math.Min(temp1, temp2);
temp1 = Math.Max(d[i, j], d[i, j + 1]);
temp2 = Math.Max(d[i + 1, j], d[i + 1, j + 1]);
double dmax = Math.Max(temp1, temp2);
if (dmax >= z[0] && dmin <= z[nc - 1])
{
int k;
for (k = 0; k < nc; k++)
{
if (z[k] >= dmin && z[k] <= dmax)
{
int m;
for (m = 4; m >= 0; m--)
{
if (m > 0)
{
// The indexing of im and jm should be noted as it has to
// start from zero
h[m] = d[i + im[m - 1], j + jm[m - 1]] - z[k];
xh[m] = x[i + im[m - 1]];
yh[m] = y[j + jm[m - 1]];
}
else
{
h[0] = 0.25 * (h[1] + h[2] + h[3] + h[4]);
xh[0] = 0.5 * (x[i] + x[i + 1]);
yh[0] = 0.5 * (y[j] + y[j + 1]);
}
if (h[m] > 0.0)
{
sh[m] = 1;
}
else if (h[m] < 0.0)
{
sh[m] = -1;
}
else
{
sh[m] = 0;
}
}
//// Note: at this stage the relative heights of the corners and the
//// centre are in the h array, and the corresponding coordinates are
//// in the xh and yh arrays. The centre of the box is indexed by 0
//// and the 4 corners by 1 to 4 as shown below.
//// Each triangle is then indexed by the parameter m, and the 3
//// vertices of each triangle are indexed by parameters m1,m2,and
//// m3.
//// It is assumed that the centre of the box is always vertex 2
//// though this isimportant only when all 3 vertices lie exactly on
//// the same contour level, in which case only the side of the box
//// is drawn.
//// vertex 4 +-------------------+ vertex 3
//// | \ / |
//// | \ m-3 / |
//// | \ / |
//// | \ / |
//// | m=2 X m=2 | the centre is vertex 0
//// | / \ |
//// | / \ |
//// | / m=1 \ |
//// | / \ |
//// vertex 1 +-------------------+ vertex 2
// Scan each triangle in the box
for (m = 1; m <= 4; m++)
{
int m1 = m;
int m2 = 0;
int m3;
if (m != 4)
{
m3 = m + 1;
}
else
{
m3 = 1;
}
int caseValue = castab[sh[m1] + 1, sh[m2] + 1, sh[m3] + 1];
if (caseValue != 0)
{
switch (caseValue)
{
case 1: // Line between vertices 1 and 2
x1 = xh[m1];
y1 = yh[m1];
x2 = xh[m2];
y2 = yh[m2];
break;
case 2: // Line between vertices 2 and 3
x1 = xh[m2];
y1 = yh[m2];
x2 = xh[m3];
y2 = yh[m3];
break;
case 3: // Line between vertices 3 and 1
x1 = xh[m3];
y1 = yh[m3];
x2 = xh[m1];
y2 = yh[m1];
break;
case 4: // Line between vertex 1 and side 2-3
x1 = xh[m1];
y1 = yh[m1];
x2 = xsect(m2, m3);
y2 = ysect(m2, m3);
break;
case 5: // Line between vertex 2 and side 3-1
x1 = xh[m2];
y1 = yh[m2];
x2 = xsect(m3, m1);
y2 = ysect(m3, m1);
break;
case 6: // Line between vertex 3 and side 1-2
x1 = xh[m3];
y1 = yh[m3];
x2 = xsect(m1, m2);
y2 = ysect(m1, m2);
break;
case 7: // Line between sides 1-2 and 2-3
x1 = xsect(m1, m2);
y1 = ysect(m1, m2);
x2 = xsect(m2, m3);
y2 = ysect(m2, m3);
break;
case 8: // Line between sides 2-3 and 3-1
x1 = xsect(m2, m3);
y1 = ysect(m2, m3);
x2 = xsect(m3, m1);
y2 = ysect(m3, m1);
break;
case 9: // Line between sides 3-1 and 1-2
x1 = xsect(m3, m1);
y1 = ysect(m3, m1);
x2 = xsect(m1, m2);
y2 = ysect(m1, m2);
break;
}
renderer(x1, y1, x2, y2, z[k]);
}
}
}
}
}
}
}
}
