public async Task InitializeAsync()
{
using (var session = _performanceProfiler.CreateSession())
{
_scene.FpsChanged += SceneOnFpsChanged;
var sceneContainer = await _scenePersistenceService.LoadScene2DAsync();
if (sceneContainer == null)
{
var triangle = new Triangle2D(
new Vector2D(-50, -50),
new Vector2D(0, 50),
new Vector2D(50, -50),
GetNextColor());
_scene.Append(triangle);
await _scene.BeginShiftAsync(0, 0);
await _scene.EndShiftAsync(_width / 2, _height / 2);
return;
}
_scene.FromScene2Ds(sceneContainer);
await _scene.RenderAsync();
session.LogWithPerformance("2D scene loaded");
}
}
public void CircCenter(int exampleID)
{
Triangle2D triangle = InitExample_CircCenter(exampleID);
Point2D expectedPoint = InitExpectedPoint_CircCenter(exampleID);
Assert.That(expectedPoint.Equals(triangle.CircCenter));
}
public MeshContainer(double[,] point, int[,] element)
{
_vertex = new List <Vertex2D>();
_edge = new List <Edge2D>();
_triangle = new List <Triangle2D>();
for (int n = 0; n < point.GetLength(0); n++)
{
Vertex2D v = AddVertex(point[n, 0], point[n, 1]);
v.extID = n + 1;
}
for (int n = 0; n < element.GetLength(0); n++)
{
Vertex2D v1 = _vertex.Find(item => item.extID == element[n, 0]);
Vertex2D v2 = _vertex.Find(item => item.extID == element[n, 1]);
Vertex2D v3 = _vertex.Find(item => item.extID == element[n, 2]);
Triangle2D t = new Triangle2D(v1, v2, v3);
t.extID = n + 1;
_triangle.Add(t);
t.E1 = AddEdgeIfNotExist(v1, v2);
t.E2 = AddEdgeIfNotExist(v2, v3);
t.E3 = AddEdgeIfNotExist(v3, v1);
}
}
public void Constructor()
{
var triangle = new Triangle2D(new Point(1, 2), new Point(3, 4), new Point(5, 6));
Assert.AreEqual(new Point(1, 2), triangle.Corner1);
Assert.AreEqual(new Point(3, 4), triangle.Corner2);
Assert.AreEqual(new Point(5, 6), triangle.Corner3);
}
public static bool IsCollision(Triangle2D tri, Rectangle2D rect)
{
if (IsCollision(tri, new Triangle2D(rect.leftUp, rect.leftDown, rect.rightDown)) || IsCollision(tri, new Triangle2D(rect.leftUp, rect.rightUp, rect.rightDown)))
{
return(true);
}
return(false);
}
public void Orientation_Negative_sgnNegative()
{
Triangle2D triangle = new Triangle2D(new Point2D(0, 0),
new Point2D(0, 1),
new Point2D(1, 0));
Assert.That(triangle.Orientation == Signum.Negative);
}
static internal double AreaQuality(Triangle2D triangle)
{
double Area = triangle.A.X * triangle.B.Y + triangle.B.X * triangle.C.Y + triangle.C.X * triangle.A.Y - triangle.A.Y * triangle.B.X - triangle.B.Y * triangle.C.X - triangle.C.Y * triangle.A.X;
Area /= 2;
return(1 / Math.Abs(Area));
}
public void Corner3()
{
var triangle = new Triangle2D {
Corner3 = Vector2D.Half
};
Assert.AreEqual(Vector2D.Half, triangle.Corner3);
}
public void Orientation_Degenerate_sgnZero()
{
Triangle2D triangle = new Triangle2D(new Point2D(0, 0),
new Point2D(1, 0),
new Point2D(2, 0));
Assert.That(triangle.Orientation == Signum.Zero);
}
/*----------------------------------------------------------------------*/
public TriangleMesh2D(int[,] mesh, Vector2[] vertices)
{
triangles = new Triangle2D[mesh.GetLength(0)];
for (int i = 0; i < triangles.Length; ++i)
{
triangles[i] = new Triangle2D(vertices[mesh[i, 0]], vertices[mesh[i, 1]], vertices[mesh[i, 2]]);
}
}
public void Constructor()
{
var triangle = new Triangle2D(new Vector2D(1, 2), new Vector2D(3, 4), new Vector2D(5, 6));
Assert.AreEqual(new Vector2D(1, 2), triangle.Corner1);
Assert.AreEqual(new Vector2D(3, 4), triangle.Corner2);
Assert.AreEqual(new Vector2D(5, 6), triangle.Corner3);
}
public void DefaultConstructor()
{
var triangle = new Triangle2D();
Assert.AreEqual(Point.Zero, triangle.Corner1);
Assert.AreEqual(Point.Zero, triangle.Corner2);
Assert.AreEqual(Point.Zero, triangle.Corner3);
Assert.AreEqual(triangle, Triangle2D.Zero);
}
/// <summary>
/// Gets the centroid of the polyline 2d.
/// </summary>
/// <param name="pl">The instance to which the method applies.</param>
/// <returns>The centroid of the polyline 2d (WCS coordinates).</returns>
public static Point3d Centroid(this Polyline2d pl)
{
var vertices = pl.GetVertices().ToArray();
var last = vertices.Length - 1;
var vertex = vertices[0];
var p0 = vertex.Position.Convert2D();
_ = pl.Elevation;
var cen = new Point2d(0.0, 0.0);
var area = 0.0;
var bulge = vertex.Bulge;
double tmpArea;
Point2d tmpPt;
var tri = new Triangle2D();
var arc = new CircularArc2d();
if (bulge != 0.0)
{
arc = pl.GetArcSegment2DAt(0);
tmpArea = arc.AlgebricArea();
tmpPt = arc.Centroid();
area += tmpArea;
cen += (new Point2d(tmpPt.X, tmpPt.Y) * tmpArea).GetAsVector();
}
for (var i = 1; i < last; i++)
{
var p1 = vertices[i].Position.Convert2D();
var p2 = vertices[i + 1].Position.Convert2D();
tri.Set(p0, p1, p2);
tmpArea = tri.AlgebricArea;
area += tmpArea;
cen += (tri.Centroid * tmpArea).GetAsVector();
bulge = vertices[i].Bulge;
if (bulge != 0.0)
{
arc = pl.GetArcSegment2DAt(i);
tmpArea = arc.AlgebricArea();
tmpPt = arc.Centroid();
area += tmpArea;
cen += (new Point2d(tmpPt.X, tmpPt.Y) * tmpArea).GetAsVector();
}
}
bulge = vertices[last].Bulge;
if (bulge != 0.0 && pl.Closed)
{
arc = pl.GetArcSegment2DAt(last);
tmpArea = arc.AlgebricArea();
tmpPt = arc.Centroid();
area += tmpArea;
cen += (new Point2d(tmpPt.X, tmpPt.Y) * tmpArea).GetAsVector();
}
cen = cen.DivideBy(area);
return(new Point3d(cen.X, cen.Y, pl.Elevation).TransformBy(Matrix3d.PlaneToWorld(pl.Normal)));
}
public void DefaultConstructor()
{
var triangle = new Triangle2D();
Assert.AreEqual(Vector2D.Zero, triangle.Corner1);
Assert.AreEqual(Vector2D.Zero, triangle.Corner2);
Assert.AreEqual(Vector2D.Zero, triangle.Corner3);
Assert.AreEqual(triangle, Triangle2D.Zero);
}
public void flattenMesh()
{
for (int i = 0; i < vertices.Length; i++)
{
vertices[i].z = 0;
}
motherTriangle = new Triangle2D(vertices[triangles[0]], vertices[triangles[1]], vertices[triangles[2]]);
}
public static bool IsCollision(Triangle2D tri1, Triangle2D tri2)
{
if (IsCollision(tri1, tri2.p1) || IsCollision(tri1, tri2.p2) || IsCollision(tri1, tri2.p3) ||
IsCollision(tri2, tri1.p1) || IsCollision(tri2, tri1.p2) || IsCollision(tri2, tri1.p3))
{
return(true);
}
return(false);
}
public void RenderTest()
{
var blackColor = Color.Black;
var goldColor = Color.Gold;
var canvas = new CanvasMock(20, 13, blackColor);
var sut = new Triangle2D(
new Vector2D(13, 10),
new Vector2D(17, 8),
new Vector2D(18, 11),
goldColor);
sut.Render(canvas);
canvas[13, 8].Should().BeEquivalentTo(blackColor);
canvas[14, 8].Should().BeEquivalentTo(blackColor);
canvas[15, 8].Should().BeEquivalentTo(blackColor);
canvas[16, 8].Should().BeEquivalentTo(goldColor);
canvas[17, 8].Should().BeEquivalentTo(goldColor);
canvas[18, 8].Should().BeEquivalentTo(blackColor);
canvas[19, 8].Should().BeEquivalentTo(blackColor);
canvas[13, 9].Should().BeEquivalentTo(blackColor);
canvas[14, 9].Should().BeEquivalentTo(goldColor);
canvas[15, 9].Should().BeEquivalentTo(goldColor);
canvas[16, 9].Should().BeEquivalentTo(goldColor);
canvas[17, 9].Should().BeEquivalentTo(goldColor);
canvas[18, 9].Should().BeEquivalentTo(goldColor);
canvas[19, 9].Should().BeEquivalentTo(blackColor);
canvas[12, 10].Should().BeEquivalentTo(blackColor);
canvas[13, 10].Should().BeEquivalentTo(goldColor);
canvas[14, 10].Should().BeEquivalentTo(goldColor);
canvas[15, 10].Should().BeEquivalentTo(goldColor);
canvas[16, 10].Should().BeEquivalentTo(goldColor);
canvas[17, 10].Should().BeEquivalentTo(goldColor);
canvas[18, 10].Should().BeEquivalentTo(goldColor);
canvas[19, 10].Should().BeEquivalentTo(blackColor);
canvas[12, 11].Should().BeEquivalentTo(blackColor);
canvas[13, 11].Should().BeEquivalentTo(blackColor);
canvas[14, 11].Should().BeEquivalentTo(blackColor);
canvas[15, 11].Should().BeEquivalentTo(goldColor);
canvas[16, 11].Should().BeEquivalentTo(goldColor);
canvas[17, 11].Should().BeEquivalentTo(goldColor);
canvas[18, 11].Should().BeEquivalentTo(goldColor);
canvas[19, 11].Should().BeEquivalentTo(blackColor);
canvas[12, 12].Should().BeEquivalentTo(blackColor);
canvas[13, 12].Should().BeEquivalentTo(blackColor);
canvas[14, 12].Should().BeEquivalentTo(blackColor);
canvas[15, 12].Should().BeEquivalentTo(blackColor);
canvas[16, 12].Should().BeEquivalentTo(blackColor);
canvas[17, 12].Should().BeEquivalentTo(blackColor);
canvas[18, 12].Should().BeEquivalentTo(blackColor);
canvas[19, 12].Should().BeEquivalentTo(blackColor);
}
public void Triangle2DToStringAndFromString()
{
var triangle = new Triangle2D(new Vector2D(1.2f, 2.3f), new Vector2D(-3.4f, 4.5f),
new Vector2D(0.0f, -5.67f));
string triangleString = triangle.ToString();
Assert.AreEqual(triangle, new Triangle2D(triangleString));
Assert.Throws <Triangle2D.InvalidNumberOfComponents>(() => new Triangle2D("1, 2, 3"));
Assert.Throws <FormatException>(() => new Triangle2D("abc"));
}
public IndexedTriangle(Triangulation triangulation, int point1, int point2, int point3)
{
this.triangulation = triangulation;
p1 = point1;
p2 = point2;
p3 = point3;
manifestation = new Triangle2D(triangulation.VertexAt(p1),
triangulation.VertexAt(p2),
triangulation.VertexAt(p3));
}
public override bool Equals(object obj)
{
if (!(obj is Triangle2D))
{
return(false);
}
Triangle2D other = (Triangle2D)obj;
return(a.Equals(other.a) && b.Equals(other.b) && c.Equals(other.c));
}
public void GetCentroid()
{
Triangle2D triangle = new Triangle2D(new Point2D(0, 0),
new Point2D(1, 0),
new Point2D(0, 1));
Point2D centroidExpected = new Point2D(0.3333333, 0.3333333);
Point2D centroidActual = triangle.Centroid;
Assert.That(centroidExpected.Equals(centroidActual));
}
public void Equals()
{
var triangle1 = new Triangle2D(new Point(1, 2), new Point(3, 4), new Point(5, 6));
var triangle2 = new Triangle2D(new Point(11, 12), new Point(13, 14), new Point(15, 16));
Assert.AreNotEqual(triangle1, triangle2);
Assert.AreEqual(triangle1, new Triangle2D(new Point(1, 2), new Point(3, 4), new Point(5, 6)));
Assert.IsTrue(triangle1 == new Triangle2D(new Point(1, 2), new Point(3, 4), new Point(5, 6)));
Assert.IsTrue(triangle1 != triangle2);
Assert.IsFalse(triangle1.Equals(triangle2));
Assert.IsTrue(triangle1.Equals(triangle1));
}
public void GetHashCodeViaDictionary()
{
var triangle1 = new Triangle2D(new Point(1, 2), new Point(3, 4), new Point(5, 6));
var triangle1Similar = new Triangle2D(new Point(1, 2), new Point(3, 4), new Point(15, 16));
var triangle2 = new Triangle2D(new Point(11, 12), new Point(13, 14), new Point(15, 16));
var triangles = new Dictionary<Triangle2D, int> { { triangle1, 1 }, { triangle2, 2 } };
Assert.IsTrue(triangles.ContainsKey(triangle1));
Assert.IsTrue(triangles.ContainsKey(triangle2));
Assert.IsFalse(
triangles.ContainsKey(new Triangle2D(new Point(1, 2), new Point(3, 4), new Point(5, 7))));
Assert.AreNotEqual(triangle1.GetHashCode(), triangle1Similar.GetHashCode());
}
static internal double ShapeQuality(Triangle2D triangle)
{
//double angle = TriangleQuality(triangle);
//double Area = triangle.A.X * triangle.B.Y + triangle.B.X * triangle.C.Y + triangle.C.X * triangle.A.Y - triangle.A.Y * triangle.B.X - triangle.B.Y * triangle.C.X - triangle.C.Y * triangle.A.X;
//Area /= 2;
//return Math.Exp(2*(angle - Math.PI / 3)) / Math.Abs(Area);
double val = 0.05 / Math.Max(triangle.AB.Length, Math.Max(triangle.AC.Length, triangle.BC.Length));
return(val);
}
public void Fill()
{
Triangle2D superTriangle = findSuperTriangle(min - new Vector2(1, 1), max + new Vector2(1, 1));
triangles.Add(superTriangle);
foreach (Edge2D point in perimiter)
{
processPoint(point.a);
processPoint(point.b);
}
// Cleanup
int intersections;
badTriangles.Clear();
foreach (Triangle2D tri in triangles)
{
// If the triangle has a corner of the super triangle, remove it
if (tri.HasPoint(superTriangle.a) || tri.HasPoint(superTriangle.b) ||
tri.HasPoint(superTriangle.c))
{
badTriangles.Add(tri);
continue;
}
// For an arbitrary line from the centre of the triangle,
// see how many times we cross the perimiter.
// If this is even, we are outside the perimiter.
if (checkForHoles)
{
intersections = 0;
Point2D centroid = tri.CentroidPoint();
foreach (Edge2D edge in perimiter)
{
if (edge.Intersects(centroid, superTriangle.a))
{
++intersections;
}
}
if (intersections % 2 == 0)
{
badTriangles.Add(tri);
}
}
}
foreach (Triangle2D tri in badTriangles)
{
triangles.Remove(tri);
}
}
private bool IsReflexPointInsideTriangle(Triangle2D t, int a, int b, int c)
{
for (int i = 0; i < reflexVertices.Count; i++)
{
Vector2D p = GetPoint(reflexVertices[i]);
if (t.IsInside(p))
{
return(true);
}
}
return(false);
}
public bool Intersects(Triangle2D otherTriangle)
{
return
(Math2d.CheckLinesIntersect(this.V1, this.V2, otherTriangle.V1, otherTriangle.V2) ||
Math2d.CheckLinesIntersect(this.V1, this.V2, otherTriangle.V2, otherTriangle.V3) ||
Math2d.CheckLinesIntersect(this.V1, this.V2, otherTriangle.V3, otherTriangle.V1) ||
Math2d.CheckLinesIntersect(this.V2, this.V3, otherTriangle.V1, otherTriangle.V2) ||
Math2d.CheckLinesIntersect(this.V2, this.V3, otherTriangle.V2, otherTriangle.V3) ||
Math2d.CheckLinesIntersect(this.V2, this.V3, otherTriangle.V3, otherTriangle.V1) ||
Math2d.CheckLinesIntersect(this.V3, this.V1, otherTriangle.V1, otherTriangle.V2) ||
Math2d.CheckLinesIntersect(this.V3, this.V1, otherTriangle.V2, otherTriangle.V3) ||
Math2d.CheckLinesIntersect(this.V3, this.V1, otherTriangle.V3, otherTriangle.V1));
}
private static Triangle2D[] GetTriangles(Vector2[] verts, int[] triIndices)
{
Triangle2D[] tris = new Triangle2D[triIndices.Length / 3];
for (int i = 0; i < tris.Length; i++)
{
tris[i] = new Triangle2D(
verts[triIndices[i * 3]],
verts[triIndices[i * 3 + 1]],
verts[triIndices[i * 3 + 2]]
);
}
return(tris);
}
public bool overlaps(Triangle2D sec)
{
return
(intersection(p1, p2, sec.p1, sec.p2) ||
intersection(p1, p2, sec.p2, sec.p3) ||
intersection(p1, p2, sec.p1, sec.p3) ||
intersection(p2, p3, sec.p1, sec.p2) ||
intersection(p2, p3, sec.p2, sec.p3) ||
intersection(p2, p3, sec.p1, sec.p3) ||
intersection(p1, p3, sec.p1, sec.p2) ||
intersection(p1, p3, sec.p2, sec.p3) ||
intersection(p1, p3, sec.p1, sec.p3));
}
/// <summary>
/// Compute a measure of quality for the given face that ranges
/// from 0 (degenerate triangle) to 1 (equilateral triangle)
/// </summary>
/// <param name="face"></param>
private static double Quality(TFace face)
{
if (face.EdgeCount != 3)
{
throw new ArgumentException("Face must be triangular");
}
// The quality measure we use is (Sqrt(3) / 36) * (Area / Perimeter^2) which is dimensionless
Triangle2D triangle = new Triangle2D(face.Vertices.Cast <IPositionable2D>().Select(v => v.Position));
const double factor = 20.7846097; // 36 / Sqrt(3);
double quality = factor * triangle.Area / Math.Pow(triangle.Perimeter, 2);
return(quality);
}
public static bool IsCollision(Triangle2D tri, Circle2D circle)
{
if (IsCollision(new Line2D(tri.p1, tri.p2), circle) || IsCollision(new Line2D(tri.p1, tri.p3), circle) || IsCollision(new Line2D(tri.p2, tri.p3), circle))
{
return(true);
}
if (IsCollision(tri, circle.point))
{
return(true);
}
return(false);
}
public void Execute(IVectorImageProvider imageProvider)
{
bool hasIntersections = false;
VectorCloud2D cloud = new VectorCloud2D(imageProvider.CurrImage.GetPrimitives <Vector2D>());
for (int i = 0; i < cloud.Count - 2; i++)
{
Vector2D v1 = cloud[i];
Vector2D v2 = cloud[i + 1];
Vector2D v3 = cloud[i + 2];
int countEqual = 0;
if (v1.IsPositionEqual(v2))
{
countEqual++;
}
if (v1.IsPositionEqual(v3))
{
countEqual++;
}
if (v2.IsPositionEqual(v3))
{
countEqual++;
}
bool isJumpLine = countEqual > 0;
if (isJumpLine)
{
imageProvider.CurrImage.Add(new Line2D(v1, v2));
imageProvider.CurrImage.Add(new Line2D(v2, v3));
imageProvider.CurrImage.Add(new Line2D(v3, v1));
}
else
{
Triangle2D t = new Triangle2D(v1, v2, v3);
if (CheckTriangleListIntersection(imageProvider.CurrImage, t))
{
hasIntersections = true;
PrimitiveRenderData.Get(t).Color = Color.Lime;
PrimitiveRenderData.Get(t.a).Color = Color.Lime;
PrimitiveRenderData.Get(t.b).Color = Color.Lime;
PrimitiveRenderData.Get(t.c).Color = Color.Lime;
}
imageProvider.CurrImage.Add(t);
}
}
if (hasIntersections)
{
MessageBox.Show("Has intersections!!!!!!");
}
}
/// <summary>
/// Process a stack of triangles checking whether they fulfill the Delaunay constraint with respect to their adjacents, swapping edges if they do not.
/// The adjacent triangles of the processed triangles are added to the stack too, so the check propagates until they all fulfill the condition.
/// </summary>
/// <param name="adjacentTrianglesToProcess">Initial set of triangles to check.</param>
private void FulfillDelaunayConstraint(Stack <int> adjacentTrianglesToProcess)
{
while (adjacentTrianglesToProcess.Count > 0)
{
int currentTriangleToSwap = adjacentTrianglesToProcess.Pop();
DelaunayTriangle triangle = m_triangleSet.GetTriangle(currentTriangleToSwap);
const int OPPOSITE_TRIANGLE_INDEX = 1;
if (triangle.adjacent[OPPOSITE_TRIANGLE_INDEX] == NO_ADJACENT_TRIANGLE)
{
continue;
}
const int NOT_IN_EDGE_VERTEX_INDEX = 0;
Vector2 triangleVertexNotInEdge = m_triangleSet.GetPointByIndex(triangle.p[NOT_IN_EDGE_VERTEX_INDEX]);
DelaunayTriangle oppositeTriangle = m_triangleSet.GetTriangle(triangle.adjacent[OPPOSITE_TRIANGLE_INDEX]);
Triangle2D oppositeTrianglePoints = m_triangleSet.GetTrianglePoints(triangle.adjacent[OPPOSITE_TRIANGLE_INDEX]);
if (MathUtils.IsPointInsideCircumcircle(oppositeTrianglePoints.p0, oppositeTrianglePoints.p1, oppositeTrianglePoints.p2, triangleVertexNotInEdge))
{
// Finds the edge of the opposite triangle that is shared with the other triangle, this edge will be swapped
int sharedEdgeVertexLocalIndex = 0;
for (; sharedEdgeVertexLocalIndex < 3; ++sharedEdgeVertexLocalIndex)
{
if (oppositeTriangle.adjacent[sharedEdgeVertexLocalIndex] == currentTriangleToSwap)
{
break;
}
}
// Adds the 2 triangles that were adjacent to the opposite triangle, to be processed too
if (oppositeTriangle.adjacent[(sharedEdgeVertexLocalIndex + 1) % 3] != NO_ADJACENT_TRIANGLE)
{
adjacentTrianglesToProcess.Push(oppositeTriangle.adjacent[(sharedEdgeVertexLocalIndex + 1) % 3]);
}
if (oppositeTriangle.adjacent[(sharedEdgeVertexLocalIndex + 2) % 3] != NO_ADJACENT_TRIANGLE)
{
adjacentTrianglesToProcess.Push(oppositeTriangle.adjacent[(sharedEdgeVertexLocalIndex + 2) % 3]);
}
// 4.8: Swap edges
SwapEdges(currentTriangleToSwap, triangle, NOT_IN_EDGE_VERTEX_INDEX, oppositeTriangle, sharedEdgeVertexLocalIndex);
}
}
}
public void Init()
{
_triangles = _mesh.triangles;
_vertices = _mesh.vertices;
_normals = _mesh.normals;
_uvs = _mesh.uv;
var triangleCount = _triangles.Length / 3;
_uvTris = new Triangle2D[triangleCount];
for (var i = 0; i < triangleCount; i++) {
Vector2 uva, uvb, uvc;
TriangleUvs(i, out uva, out uvb, out uvc);
_uvTris[i] = new Triangle2D(uva, uvb, uvc);
}
}
public void Init()
{
_triangles = _mesh.triangles;
_vertices = _mesh.vertices;
_normals = _mesh.normals;
_uvs = _mesh.uv;
var triangleCount = _triangles.Length / 3;
_uvTris = new Triangle2D[triangleCount];
for (var i = 0; i < triangleCount; i++)
{
_uvTris [i] = new Triangle2D(i, _vertices, _uvs, _normals, _triangles);
}
}
public void Triangle2DToString()
{
var triangle = new Triangle2D(new Point(1, 2), new Point(3, 4), new Point(5, 6));
Assert.AreEqual("(1, 2) (3, 4) (5, 6)", triangle.ToString());
}
public void Corner3()
{
var triangle = new Triangle2D { Corner3 = Point.Half };
Assert.AreEqual(Point.Half, triangle.Corner3);
}
/*
// Create a new bitmap.
Bitmap bmp = new Bitmap("c:\\fakePhoto.jpg");
// Lock the bitmap's bits.
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
System.Drawing.Imaging.BitmapData bmpData =
bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite,
bmp.PixelFormat);
// Get the address of the first line.
IntPtr ptr = bmpData.Scan0;
// Declare an array to hold the bytes of the bitmap.
int bytes = Math.Abs(bmpData.Stride) * bmp.Height;
��� byte[] rgbValues = new byte[bytes];
// Copy the RGB values into the array.
System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);
// Set every third value to 255. A 24bpp bitmap will look red.
for (int counter = 2; counter < rgbValues.Length; counter += 3)
rgbValues[counter] = 255;
// Copy the RGB values back to the bitmap
System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);
// Unlock the bits.
bmp.UnlockBits(bmpData);
// Draw the modified image.
e.Graphics.DrawImage(bmp, 0, 150);
*/
/*private void FromBitmap(Bitmap b,Int32[,] pole){
for(int i = 0;i<b.Width;i++)
for(int j = 0;j<b.Height;j++){
pole[i,j] = b.GetPixel(i,j).ToArgb();
}
}
private unsafe Bitmap ToBitmap(Int32[,] pole){
Bitmap b;
fixed(int* pp = &pole[0,0])
b= new Bitmap(pole.GetLength(1), pole.GetLength(0),pole.GetLength(1)*4, System.Drawing.Imaging.PixelFormat.Format32bppArgb,(IntPtr)pp);
return b;
}*/
void OnPaint(object sender, PaintEventArgs e)
{
//= new Bitmap(e.ClipRectangle.Width, e.ClipRectangle.Height, e.Graphics);
//MyUnion union;
if((e.ClipRectangle.Height != oldy) || (e.ClipRectangle.Width != oldx))
{
pole = new Int32[e.ClipRectangle.Height,e.ClipRectangle.Width];
oldx = e.ClipRectangle.Width; oldy = e.ClipRectangle.Height;
}else{Array.Clear(pole, 0, pole.Length);}
//byte[] bytes = new byte[b.Width*b.Height*4];
//Int32[,] pole = new Int32[b.Width,b.Height];
Soft3DScreen s = new Soft3DScreen(pole);
Triangle3D t3;
Triangle2D t2;
s.ViewMatrix.Translate(0,0,-5);
s.ViewMatrix.RotateX(rx);
s.ViewMatrix.RotateY(ry);
Vector2 texcoord1 = new Vector2(-1,-1);
Vector2 texcoord2 = new Vector2(-1,1);
Vector2 texcoord3 = new Vector2(1,-1);
Vector3 v1 = new Vector3(-1,-1,-1);
Vector3 v2 = new Vector3(-1,1,-1);
Vector3 v3 = new Vector3(1,-1,-1);
t3 = new Triangle3D(v1,v2,v3);
t2 = new Triangle2D(texcoord1,texcoord2,texcoord3);
TexturedTriangle ttriangle = new TexturedTriangle(t3,t2,texture);
s.DrawTexturedTriangle3d(ttriangle);
texcoord1.Set(-1,1);
texcoord2.Set(1,1);
texcoord3.Set(1,-1);
v1.Set(-1,1,-1);
v2.Set(1,1,-1);
v3.Set(1,-1,-1);
t3 = new Triangle3D(v1,v2,v3);
t2 = new Triangle2D(texcoord1,texcoord2,texcoord3);
ttriangle = new TexturedTriangle(t3,t2,texture);
s.DrawTexturedTriangle3d(ttriangle);
/* s.ActualColor = Color.White.ToArgb();
v1.Set(-1,1,1);
v2.Set(1,1,1);
v3.Set(1,-1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);
v1.Set(-1,1,1);
v2.Set(-1,-1,1);
v3.Set(1,-1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);
s.ActualColor = Color.Green.ToArgb();
v1.Set(1,1,1);
v2.Set(1,1,-1);
v3.Set(1,-1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);
v1.Set(1,-1,-1);
v2.Set(1,1,-1);
v3.Set(1,-1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);
s.ActualColor = Color.Blue.ToArgb();
v1.Set(-1,1,1);
v2.Set(-1,1,-1);
v3.Set(-1,-1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);;
v1.Set(-1,-1,-1);
v2.Set(-1,1,-1);
v3.Set(-1,-1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);
s.ActualColor = Color.Cyan.ToArgb();
v1.Set(1,1,1);
v2.Set(1,1,-1);
v3.Set(-1,1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);
v1.Set(-1,1,-1);
v2.Set(-1,1,1);
v3.Set(1,1,-1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);
s.ActualColor = Color.Orange.ToArgb();
v1.Set(1,-1,1);
v2.Set(1,-1,-1);
v3.Set(-1,-1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);
v1.Set(-1,-1,-1);
v2.Set(1,-1,-1);
v3.Set(-1,-1,1);
//t3 = new Triangle3D(v1,v2,v3);
s.DrawFilledTriangle3d(v1,v2,v3);*/
Bitmap b = Soft3DBitmap.ToBitmap(pole);
e.Graphics.DrawImageUnscaled(b, 0, 0);
//e.Graphics.DrawImageUnscaled(texture, 0, 0);
}
public void Triangle2DToStringAndFromString()
{
var triangle = new Triangle2D(new Point(1.2f, 2.3f), new Point(-3.4f, 4.5f),
new Point(0.0f, -5.67f));
string triangleString = triangle.ToString();
Assert.AreEqual(triangle, new Triangle2D(triangleString));
Assert.Throws<Triangle2D.InvalidNumberOfComponents>(() => new Triangle2D("abc"));
}
public bool Equals(Triangle2D other)
{
return Corner1 == other.Corner1 && Corner2 == other.Corner2 && Corner3 == other.Corner3;
}
