protected override void Triangulate( DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { // Clear all four collections. vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // Convert TextGeometry to series of closed polylines. PathGeometry path = TextGeometry.GetFlattenedPathGeometry(0.001, ToleranceType.Relative); foreach (PathFigure fig in path.Figures) { list.Clear(); list.Add(fig.StartPoint); foreach (PathSegment seg in fig.Segments) { if (seg is LineSegment) { LineSegment lineseg = seg as LineSegment; list.Add(lineseg.Point); } else if (seg is PolyLineSegment) { PolyLineSegment polyline = seg as PolyLineSegment; for (int i = 0; i < polyline.Points.Count; i++) list.Add(polyline.Points[i]); } } // Figure is complete. Post-processing follows. if (list.Count > 0) { // Remove last point if it's the same as the first. if (list[0] == list[list.Count - 1]) list.RemoveAt(list.Count - 1); // Convert points to Y increasing up. for (int i = 0; i < list.Count; i++) { Point pt = list[i]; pt.Y = 2 * Origin.Y - pt.Y; list[i] = pt; } // For each figure, process the points. ProcessFigure(list, vertices, normals, indices, textures); } } }
protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); MeshGeometry3D mesh = MeshGenerator.Geometry; foreach (Point3D vertex in mesh.Positions) vertices.Add(vertex); foreach (Vector3D normal in mesh.Normals) normals.Add(normal); foreach (int index in mesh.TriangleIndices) indices.Add(index); foreach (Point texture in mesh.TextureCoordinates) textures.Add(texture); }
/// <summary> /// /// </summary> /// <param name="args"></param> /// <param name="vertices"></param> /// <param name="normals"></param> /// <param name="indices"></param> /// <param name="textures"></param> protected override void Triangulate( DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { // Clear all four collections. vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // Fill the vertices, normals, and textures collections. for (int stack = 0; stack <= Stacks; stack++) { double y = Length - stack * Length / Stacks; for (int slice = 0; slice <= Slices; slice++) { double theta = slice * 2 * Math.PI / Slices; double x = -Radius * Math.Sin(theta); double z = -Radius * Math.Cos(theta); normals.Add(new Vector3D(x, 0, z)); vertices.Add(new Point3D(x, y, z)); textures.Add(new Point((double)slice / Slices, (double)stack / Stacks)); } } // Fill the indices collection. for (int stack = 0; stack < Stacks; stack++) { for (int slice = 0; slice < Slices; slice++) { indices.Add((stack + 0) * (Slices + 1) + slice); indices.Add((stack + 1) * (Slices + 1) + slice); indices.Add((stack + 0) * (Slices + 1) + slice + 1); indices.Add((stack + 0) * (Slices + 1) + slice + 1); indices.Add((stack + 1) * (Slices + 1) + slice); indices.Add((stack + 1) * (Slices + 1) + slice + 1); } } }
protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); Point3D[,] faces = Faces; PointCollection texturesBase = TextureCoordinates; int indexTextures = 0; for (int face = 0; face < faces.GetLength(0); face++) { Vector3D normal = Vector3D.CrossProduct(faces[face, 1] - faces[face, 0], faces[face, 2] - faces[face, 0]); // For faces that are triangles. if (faces.GetLength(1) == 3) { int indexBase = vertices.Count; for (int i = 0; i < 3; i++) { vertices.Add(faces[face, i]); normals.Add(normal); indices.Add(indexBase + i); if (texturesBase != null && texturesBase.Count > 0) { textures.Add(texturesBase[indexTextures]); indexTextures = (indexTextures + 1) % texturesBase.Count; } } if (Slices > 1) TriangleSubdivide(vertices, normals, indices, textures); } // For faces that are not triangles. else { for (int i = 0; i < faces.GetLength(1) - 1; i++) { int indexBase = vertices.Count; int num = faces.GetLength(1) - 1; vertices.Add(faces[face, 0]); vertices.Add(faces[face, i + 1]); vertices.Add(faces[face, (i + 1) % num + 1]); if (texturesBase != null && texturesBase.Count >= faces.GetLength(1)) { textures.Add(texturesBase[indexTextures + 0]); textures.Add(texturesBase[indexTextures + i + 1]); textures.Add(texturesBase[indexTextures + (i + 1) % num + 1]); } normals.Add(normal); normals.Add(normal); normals.Add(normal); indices.Add(indexBase + 0); indices.Add(indexBase + 1); indices.Add(indexBase + 2); if (Slices > 1) TriangleSubdivide(vertices, normals, indices, textures); } if (texturesBase != null && texturesBase.Count > 0) indexTextures = (indexTextures + faces.GetLength(1)) % texturesBase.Count; } } }
/// <summary> /// /// </summary> /// <param name="args"> /// The DependencyPropertyChangedEventArgs object originally /// passed to the PropertyChanged handler that initiated this /// recalculation. /// </param> /// <param name="vertices"> /// The Point3DCollection corresponding to the Positions property /// of the MeshGeometry3D. /// </param> /// <param name="normals"> /// The Vector3DCollection corresponding to the Normals property /// of the MeshGeometry3D. /// </param> /// <param name="indices"> /// The Int32Collection corresponding to the TriangleIndices /// property of the MeshGeometry3D. /// </param> /// <param name="textures"> /// The PointCollection corresponding to the TextureCoordinates /// property of the MeshGeometry3D. /// </param> protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { // Clear all four collections. vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // Loop for outside (side = 1) and inside (side = -1). for (int side = 1; side >= -1; side -= 2) { int offset = vertices.Count; // Begin at the top end. Fill the collections. for (int stack = 0; stack <= EndStacks; stack++) { double y = Length; double radius = Radius + side * stack * Thickness / 2 / EndStacks; int top = offset + (stack + 0) * (Slices + 1); int bot = offset + (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { double theta = slice * 2 * Math.PI / Slices; double x = -radius * Math.Sin(theta); double z = -radius * Math.Cos(theta); vertices.Add(new Point3D(x, y, z)); normals.Add(new Vector3D(0, side, 0)); textures.Add(new Point((double)slice / Slices, Fold * stack / EndStacks)); if (stack < EndStacks && slice < Slices) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } offset = vertices.Count; // Length of the tube: Fill in the collections. for (int stack = 0; stack <= Stacks; stack++) { double y = Length - stack * Length / Stacks; int top = offset + (stack + 0) * (Slices + 1); int bot = offset + (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { double theta = slice * 2 * Math.PI / Slices; double x = -(Radius + side * Thickness / 2) * Math.Sin(theta); double z = -(Radius + side * Thickness / 2) * Math.Cos(theta); vertices.Add(new Point3D(x, y, z)); normals.Add(new Vector3D(side * x, 0, side * z)); textures.Add(new Point((double)slice / Slices, Fold + (1 - 2 * Fold) * stack / Stacks)); if (stack < Stacks && slice < Slices) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } offset = vertices.Count; // Finish with the bottom end. Fill the collections. for (int stack = 0; stack <= EndStacks; stack++) { double y = 0; double radius = Radius + side * Thickness / 2 * (1 - (double)stack / EndStacks); int top = offset + (stack + 0) * (Slices + 1); int bot = offset + (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { double theta = slice * 2 * Math.PI / Slices; double x = -radius * Math.Sin(theta); double z = -radius * Math.Cos(theta); vertices.Add(new Point3D(x, y, z)); normals.Add(new Vector3D(0, -side, 0)); textures.Add(new Point((double)slice / Slices, (1 - Fold) + Fold * stack / EndStacks)); if (stack < EndStacks && slice < Slices) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } } }
/// <summary> /// /// </summary> /// <param name="args"></param> /// <param name="vertices"></param> /// <param name="normals"></param> /// <param name="indices"></param> /// <param name="textures"></param> protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { // Clear all four collections. vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); double x, y, z; int indexBase = 0; // Front side. // ----------- z = Depth / 2; // Fill the vertices, normals, textures collections. for (int stack = 0; stack <= Stacks; stack++) { y = Height / 2 - stack * Height / Stacks; for (int slice = 0; slice <= Slices; slice++) { x = -Width / 2 + slice * Width / Slices; Point3D point = new Point3D(x, y, z); vertices.Add(point); normals.Add(point - new Point3D(x, y, 0)); textures.Add(new Point((double)slice / Slices, (double)stack / Stacks)); } } // Fill the indices collection. for (int stack = 0; stack < Stacks; stack++) { for (int slice = 0; slice < Slices; slice++) { indices.Add((stack + 0) * (Slices + 1) + slice); indices.Add((stack + 1) * (Slices + 1) + slice); indices.Add((stack + 0) * (Slices + 1) + slice + 1); indices.Add((stack + 0) * (Slices + 1) + slice + 1); indices.Add((stack + 1) * (Slices + 1) + slice); indices.Add((stack + 1) * (Slices + 1) + slice + 1); } } // Rear side. // ----------- indexBase = vertices.Count; z = -Depth / 2; // Fill the vertices, normals, textures collections. for (int stack = 0; stack <= Stacks; stack++) { y = Height / 2 - stack * Height / Stacks; for (int slice = 0; slice <= Slices; slice++) { x = Width / 2 - slice * Width / Slices; Point3D point = new Point3D(x, y, z); vertices.Add(point); normals.Add(point - new Point3D(x, y, 0)); textures.Add(new Point((double)slice / Slices, (double)stack / Stacks)); } } // Fill the indices collection. for (int stack = 0; stack < Stacks; stack++) { for (int slice = 0; slice < Slices; slice++) { indices.Add(indexBase + (stack + 0) * (Slices + 1) + slice); indices.Add(indexBase + (stack + 1) * (Slices + 1) + slice); indices.Add(indexBase + (stack + 0) * (Slices + 1) + slice + 1); indices.Add(indexBase + (stack + 0) * (Slices + 1) + slice + 1); indices.Add(indexBase + (stack + 1) * (Slices + 1) + slice); indices.Add(indexBase + (stack + 1) * (Slices + 1) + slice + 1); } } // Left side. // ----------- indexBase = vertices.Count; x = -Width / 2; // Fill the vertices, normals, textures collections. for (int stack = 0; stack <= Stacks; stack++) { y = Height / 2 - stack * Height / Stacks; for (int layer = 0; layer <= Layers; layer++) { z = -Depth / 2 + layer * Depth / Layers; Point3D point = new Point3D(x, y, z); vertices.Add(point); normals.Add(point - new Point3D(0, y, z)); textures.Add(new Point((double)layer / Layers, (double)stack / Stacks)); } } // Fill the indices collection. for (int stack = 0; stack < Stacks; stack++) { for (int layer = 0; layer < Layers; layer++) { indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer); indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer); indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer + 1); indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer + 1); indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer); indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer + 1); } } // Right side. // ----------- indexBase = vertices.Count; x = Width / 2; // Fill the vertices, normals, textures collections. for (int stack = 0; stack <= Stacks; stack++) { y = Height / 2 - stack * Height / Stacks; for (int layer = 0; layer <= Layers; layer++) { z = Depth / 2 - layer * Depth / Layers; Point3D point = new Point3D(x, y, z); vertices.Add(point); normals.Add(point - new Point3D(0, y, z)); textures.Add(new Point((double)layer / Layers, (double)stack / Stacks)); } } // Fill the indices collection. for (int stack = 0; stack < Stacks; stack++) { for (int layer = 0; layer < Layers; layer++) { indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer); indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer); indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer + 1); indices.Add(indexBase + (stack + 0) * (Layers + 1) + layer + 1); indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer); indices.Add(indexBase + (stack + 1) * (Layers + 1) + layer + 1); } } // Top side. // ----------- indexBase = vertices.Count; y = Height / 2; // Fill the vertices, normals, textures collections. for (int layer = 0; layer <= Layers; layer++) { z = -Depth / 2 + layer * Depth / Layers; for (int slice = 0; slice <= Slices; slice++) { x = -Width / 2 + slice * Width / Slices; Point3D point = new Point3D(x, y, z); vertices.Add(point); normals.Add(point - new Point3D(x, 0, z)); textures.Add(new Point((double)slice / Slices, (double)layer / Layers)); } } // Fill the indices collection. for (int layer = 0; layer < Layers; layer++) { for (int slice = 0; slice < Slices; slice++) { indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice); indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice); indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice + 1); indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice + 1); indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice); indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice + 1); } } // Bottom side. // ----------- indexBase = vertices.Count; y = -Height / 2; // Fill the vertices, normals, textures collections. for (int layer = 0; layer <= Layers; layer++) { z = Depth / 2 - layer * Depth / Layers; for (int slice = 0; slice <= Slices; slice++) { x = -Width / 2 + slice * Width / Slices; Point3D point = new Point3D(x, y, z); vertices.Add(point); normals.Add(point - new Point3D(x, 0, z)); textures.Add(new Point((double)slice / Slices, (double)layer / Layers)); } } // Fill the indices collection. for (int layer = 0; layer < Layers; layer++) { for (int slice = 0; slice < Slices; slice++) { indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice); indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice); indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice + 1); indices.Add(indexBase + (layer + 0) * (Slices + 1) + slice + 1); indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice); indices.Add(indexBase + (layer + 1) * (Slices + 1) + slice + 1); } } }
protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // vectRearRadius points towards -Z (when possible). Vector3D vectCylinder = Point2 - Point1; Vector3D vectRearRadius; if (vectCylinder.X == 0 && vectCylinder.Y == 0) { // Special case: set rear-radius vector vectRearRadius = new Vector3D(0, -1, 0); } else { // Find vector axis 90 degrees from cylinder where Z == 0 rotate.Axis = Vector3D.CrossProduct(vectCylinder, new Vector3D(0, 0, 1)); rotate.Angle = -90; // Rotate cylinder 90 degrees to find radius vector vectRearRadius = vectCylinder * xform.Value; vectRearRadius.Normalize(); } // Will rotate radius around cylinder axis rotate.Axis = -vectCylinder; // Begin at the top end. Fill the collections. for (int stack = 0; stack <= EndStacks; stack++) { double radius = stack * Radius1 / EndStacks; Vector3D vectRadius = radius * vectRearRadius; int top = (stack + 0) * (Slices + 1); int bot = (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { rotate.Angle = slice * 360.0 / Slices; vertices.Add(Point1 + vectRadius * xform.Value); normals.Add(-vectCylinder); textures.Add(new Point((double)slice / Slices, Fold1 * stack / EndStacks)); if (stack < EndStacks && slice < Slices) { if (stack != 0) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); } indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } int offset = vertices.Count; // Go down length of cylinder and fill in the collections. for (int stack = 0; stack <= Stacks; stack++) { double radius = ((Stacks - stack) * Radius1 + stack * Radius2) / Stacks; Vector3D vectRadius = radius * vectRearRadius; Point3D center = (Point3D) (Point1 + stack * vectCylinder / Stacks); int top = offset + (stack + 0) * (Slices + 1); int bot = offset + (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { rotate.Angle = slice * 360.0 / Slices; Vector3D normal = vectRadius * xform.Value; normals.Add(normal); vertices.Add(center + normal); textures.Add(new Point((double)slice / Slices, Fold1 + (Fold2 - Fold1) * stack / Stacks)); if (stack < Stacks && slice < Slices) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } offset = vertices.Count; // Finish with bottom. for (int stack = 0; stack <= EndStacks; stack++) { double radius = Radius2 * (1 - (double)stack / EndStacks); Vector3D vectRadius = radius * vectRearRadius; int top = offset + (stack + 0) * (Slices + 1); int bot = offset + (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { rotate.Angle = slice * 360.0 / Slices; vertices.Add(Point2 + vectRadius * xform.Value); normals.Add(vectCylinder); textures.Add(new Point((double)slice / Slices, Fold2 + (1 - Fold2) * stack / EndStacks)); if (stack < EndStacks && slice < Slices) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); if (stack != EndStacks - 1) { indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } } }
/* // Static method called for any property change. static void PropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args) { (obj as TorusMesh).PropertyChanged(args); } */ /// <summary> /// /// </summary> /// <param name="args"></param> /// <param name="vertices"></param> /// <param name="normals"></param> /// <param name="indices"></param> /// <param name="textures"></param> protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { // Clear all four collections. vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // Fill the vertices, normals, and textures collections. for (int stack = 0; stack <= Stacks; stack++) { double phi = stack * 2 * Math.PI / Stacks; double xCenter = Radius * Math.Sin(phi); double yCenter = Radius * Math.Cos(phi); Point3D pointCenter = new Point3D(xCenter, yCenter, 0); for (int slice = 0; slice <= Slices; slice++) { double theta = slice * 2 * Math.PI / Slices + Math.PI; double x = (Radius + TubeRadius * Math.Cos(theta)) * Math.Sin(phi); double y = (Radius + TubeRadius * Math.Cos(theta)) * Math.Cos(phi); double z = -TubeRadius * Math.Sin(theta); Point3D point = new Point3D(x, y, z); vertices.Add(point); normals.Add(point - pointCenter); textures.Add(new Point((double)slice / Slices, (double)stack / Stacks)); } } // Fill the indices collection. for (int stack = 0; stack < Stacks; stack++) { for (int slice = 0; slice < Slices; slice++) { indices.Add((stack + 0) * (Slices + 1) + slice); indices.Add((stack + 1) * (Slices + 1) + slice); indices.Add((stack + 0) * (Slices + 1) + slice + 1); indices.Add((stack + 0) * (Slices + 1) + slice + 1); indices.Add((stack + 1) * (Slices + 1) + slice); indices.Add((stack + 1) * (Slices + 1) + slice + 1); } } }
protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // Copy properties to local variables to improve speed int slices = Slices; int stacks = Stacks; double radius = Radius; Point3D ctr = Center; double lat1 = Math.Max(LatitudeFrom, LatitudeTo); // default is 90 double lat2 = Math.Min(LatitudeFrom, LatitudeTo); // default is -90 double lng1 = LongitudeFrom; // default is -180 double lng2 = LongitudeTo; // default is 180 for (int lat = 0; lat <= stacks; lat++) { double degrees = lat1 - lat * (lat1 - lat2) / stacks; double angle = Math.PI * degrees / 180; double y = radius * Math.Sin(angle); double scale = Math.Cos(angle); for (int lng = 0; lng <= slices; lng++) { double diff = lng2 - lng1; if (diff < 0) diff += 360; degrees = lng1 + lng * diff / slices; angle = Math.PI * degrees / 180; double x = radius * scale * Math.Sin(angle); double z = radius * scale * Math.Cos(angle); Vector3D vect = new Vector3D(x, y, z); vertices.Add(ctr + vect); normals.Add(vect); textures.Add(new Point((double)lng / slices, (double)lat / stacks)); } } for (int lat = 0; lat < stacks; lat++) { int start = lat * (slices + 1); int next = start + slices + 1; for (int lng = 0; lng < slices; lng++) { indices.Add(start + lng); indices.Add(next + lng); indices.Add(next + lng + 1); indices.Add(start + lng); indices.Add(next + lng + 1); indices.Add(start + lng + 1); } } }
protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // Front. for (int iy = 0; iy <= Stacks; iy++) { double y = Origin.Y + Height - iy * Height / Stacks; for (int ix = 0; ix <= Slices; ix++) { double x = Origin.X + ix * Width / Slices; vertices.Add(new Point3D(x, y, Origin.Z + Depth)); } } // Back for (int iy = 0; iy <= Stacks; iy++) { double y = Origin.Y + Height - iy * Height / Stacks; for (int ix = 0; ix <= Slices; ix++) { double x = Origin.X + Width - ix * Width / Slices; vertices.Add(new Point3D(x, y, Origin.Z)); } } // Left for (int iy = 0; iy <= Stacks; iy++) { double y = Origin.Y + Height - iy * Height / Stacks; for (int iz = 0; iz <= Slivers; iz++) { double z = Origin.Z + iz * Depth / Slivers; vertices.Add(new Point3D(Origin.X, y, z)); } } // Right for (int iy = 0; iy <= Stacks; iy++) { double y = Origin.Y + Height - iy * Height / Stacks; for (int iz = 0; iz <= Slivers; iz++) { double z = Origin.Z + Depth - iz * Depth / Slivers; vertices.Add(new Point3D(Origin.X + Width, y, z)); } } // Top for (int iz = 0; iz <= Slivers; iz++) { double z = Origin.Z + iz * Depth / Slivers; for (int ix = 0; ix <= Slices; ix++) { double x = Origin.X + ix * Width / Slices; vertices.Add(new Point3D(x, Origin.Y + Height, z)); } } // Top for (int iz = 0; iz <= Slivers; iz++) { double z = Origin.Z + Depth - iz * Depth / Slivers; for (int ix = 0; ix <= Slices; ix++) { double x = Origin.X + ix * Width / Slices; vertices.Add(new Point3D(x, Origin.Y, z)); } } for (int side = 0; side < 6; side++) { for (int iy = 0; iy <= Stacks; iy++) { double y = (double)iy / Stacks; for (int ix = 0; ix <= Slices; ix++) { double x = (double)ix / Slices; textures.Add(new Point(x, y)); } } } // Front, back, left, right for (int side = 0; side < 6; side++) { for (int iy = 0; iy < Stacks; iy++) for (int ix = 0; ix < Slices; ix++) { indices.Add(side * (Slices + 1) * (Stacks + 1) + iy * (Slices + 1) + ix); indices.Add(side * (Slices + 1) * (Stacks + 1) + (iy + 1) * (Slices + 1) + ix); indices.Add(side * (Slices + 1) * (Stacks + 1) + iy * (Slices + 1) + ix + 1); indices.Add(side * (Slices + 1) * (Stacks + 1) + iy * (Slices + 1) + ix + 1); indices.Add(side * (Slices + 1) * (Stacks + 1) + (iy + 1) * (Slices + 1) + ix); indices.Add(side * (Slices + 1) * (Stacks + 1) + (iy + 1) * (Slices + 1) + ix + 1); } } }
/// <summary> /// /// </summary> /// <param name="args"></param> /// <param name="vertices"></param> /// <param name="normals"></param> /// <param name="indices"></param> /// <param name="textures"></param> protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { // Clear all four collections. vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // Begin at the top end. Fill the collections. for (int stack = 0; stack <= EndStacks; stack++) { double y = Length; double radius = stack * Radius / EndStacks; int top = (stack + 0) * (Slices + 1); int bot = (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { double theta = slice * 2 * Math.PI / Slices; double x = -radius * Math.Sin(theta); double z = -radius * Math.Cos(theta); vertices.Add(new Point3D(x, y, z)); normals.Add(new Vector3D(0, 1, 0)); textures.Add(new Point((double)slice / Slices, Fold * stack / EndStacks)); if (stack < EndStacks && slice < Slices) { if (stack != 0) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); } indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } int offset = vertices.Count; // Length of the cylinder: Fill in the collections. for (int stack = 0; stack <= Stacks; stack++) { double y = Length - stack * Length / Stacks; int top = offset + (stack + 0) * (Slices + 1); int bot = offset + (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { double theta = slice * 2 * Math.PI / Slices; double x = -Radius * Math.Sin(theta); double z = -Radius * Math.Cos(theta); vertices.Add(new Point3D(x, y, z)); normals.Add(new Vector3D(x, 0, z)); textures.Add(new Point((double)slice / Slices, Fold + (1 - 2 * Fold) * stack / Stacks)); if (stack < Stacks && slice < Slices) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } offset = vertices.Count; // Finish with the bottom end. Fill the collections. for (int stack = 0; stack <= EndStacks; stack++) { double y = 0; double radius = (EndStacks - stack) * Radius / EndStacks; int top = offset + (stack + 0) * (Slices + 1); int bot = offset + (stack + 1) * (Slices + 1); for (int slice = 0; slice <= Slices; slice++) { double theta = slice * 2 * Math.PI / Slices; double x = -radius * Math.Sin(theta); double z = -radius * Math.Cos(theta); vertices.Add(new Point3D(x, y, z)); normals.Add(new Vector3D(0, -1, 0)); textures.Add(new Point((double)slice / Slices, (1 - Fold) + Fold * stack / EndStacks)); if (stack < EndStacks && slice < Slices) { indices.Add(top + slice); indices.Add(bot + slice); indices.Add(top + slice + 1); if (stack != EndStacks - 1) { indices.Add(top + slice + 1); indices.Add(bot + slice); indices.Add(bot + slice + 1); } } } } }
// Define a plane consisting of two triangles. protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); if (TextGeometry == null) return; Rect rect = TextGeometry.Bounds; double top = 2 * Origin.Y - rect.Top; double bot = 2 * Origin.Y - rect.Bottom; // Define triangle vertices. vertices.Add(new Point3D(rect.Left, top, Z)); vertices.Add(new Point3D(rect.Right, top, Z)); vertices.Add(new Point3D(rect.Left, bot, Z)); vertices.Add(new Point3D(rect.Right, bot, Z)); // Define texture coordinates. textures.Add(new Point(0, 0)); textures.Add(new Point(1, 0)); textures.Add(new Point(0, 1)); textures.Add(new Point(1, 1)); // Define triangle indices. indices.Add(0); indices.Add(2); indices.Add(1); indices.Add(1); indices.Add(2); indices.Add(3); }
protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); // Variables for vertices collection. Vector3D UL = (Vector3D)UpperLeft; Vector3D UR = (Vector3D)UpperRight; Vector3D LL = (Vector3D)LowerLeft; Vector3D LR = (Vector3D)LowerRight; int product = Slices * Stacks; // Variables for textures collection Point ptOrigin = new Point(0, 0); Vector vectSlice = (new Point(1, 0) - ptOrigin) / Slices; Vector vectStack = (new Point(0, 1) - ptOrigin) / Stacks; for (int stack = 0; stack <= Stacks; stack++) { for (int slice = 0; slice <= Slices; slice++) { vertices.Add((Point3D)(((Stacks - stack) * (Slices - slice) * UL + stack * (Slices - slice) * LL + (Stacks - stack) * slice * UR + stack * slice * LR) / product)); textures.Add(ptOrigin + stack * vectStack + slice * vectSlice); if (slice < Slices && stack < Stacks) { indices.Add((Slices + 1) * stack + slice); indices.Add((Slices + 1) * (stack + 1) + slice); indices.Add((Slices + 1) * stack + slice + 1); indices.Add((Slices + 1) * stack + slice + 1); indices.Add((Slices + 1) * (stack + 1) + slice); indices.Add((Slices + 1) * (stack + 1) + slice + 1); } } } }
/// <summary> /// Create a StreamGeometry given a shapefile record. /// </summary> /// <param name="record">Shapefile record.</param> /// <returns>A StreamGeometry instance.</returns> private Geometry CreateStreamGeometry(ShapeFileRecord record) { // Create a new stream geometry. StreamGeometry geometry = new StreamGeometry(); PointCollection points = new PointCollection(); // Obtain the stream geometry context for drawing each part. //using (StreamGeometryContext ctx = geometry.Open()) { // Draw figures. for (int i = 0; i < record.NumberOfParts; i++) { // Determine the starting index and the end index // into the points array that defines the figure. int start = record.Parts[i]; int end; if (record.NumberOfParts > 1 && i != (record.NumberOfParts - 1)) end = record.Parts[i + 1]; else end = record.NumberOfPoints; // Draw the figure. for (int j = start; j < end; j++) { System.Windows.Point pt = record.Points[j]; points.Add(pt); // Transform from lon/lat to canvas coordinates. //pt = this.shapeTransform.Transform(pt); // Decide if the line segments are stroked or not. For the // PolyLine type it must be stroked. bool isStroked = (record.ShapeType == (int)ShapeType.PolyLine) || !(this.geometryType == GeometryType.UseStreamGeometryNotStroked); // Register the drawing instruction. if (j == start) { } //ctx.BeginFigure(pt, true, false); //ctx.LineTo(pt, isStroked, true); } if (GeometryAdd != null) { GeometryAdd(points); points.Clear(); } } } //Geos.Add(geometry); // Return the created stream geometry. return geometry; }
/// <summary> /// /// </summary> /// <param name="args"></param> /// <param name="vertices"></param> /// <param name="normals"></param> /// <param name="indices"></param> /// <param name="textures"></param> protected override void Triangulate(DependencyPropertyChangedEventArgs args, Point3DCollection vertices, Vector3DCollection normals, Int32Collection indices, PointCollection textures) { vertices.Clear(); normals.Clear(); indices.Clear(); textures.Clear(); Vector3D normal = new Vector3D(0, 0, 1); double angleInner = 2 * Math.PI / Sides; double radius = Length / 2 / Math.Sin(angleInner / 2); double angle = 3 * Math.PI / 2 + angleInner / 2; double xMin = 0, xMax = 0, yMin = 0, yMax = 0; for (int side = 0; side < Sides; side++) { double x = Math.Cos(angle); double y = Math.Sin(angle); xMin = Math.Min(xMin, x); xMax = Math.Max(xMax, x); yMin = Math.Min(yMin, y); yMax = Math.Max(yMax, y); angle += angleInner; } angle = 3 * Math.PI / 2 + angleInner / 2; for (int side = 0; side < Sides; side++) { vertices.Add(new Point3D(0, 0, 0)); textures.Add(new Point(-xMin / (xMax - xMin), yMax / (yMax - yMin))); normals.Add(normal); double x = Math.Cos(angle); double y = Math.Sin(angle); vertices.Add(new Point3D(x, y, 0)); textures.Add(new Point((x - xMin) / (xMax - xMin), (yMax - y) / (yMax - yMin))); normals.Add(normal); angle += angleInner; x = Math.Cos(angle); y = Math.Sin(angle); vertices.Add(new Point3D(x, y, 0)); textures.Add(new Point((x - xMin) / (xMax - xMin), (yMax - y) / (yMax - yMin))); normals.Add(normal); int index = vertices.Count - 3; indices.Add(index); indices.Add(index + 1); indices.Add(index + 2); if (Slices > 1) TriangleSubdivide(vertices, normals, indices, textures); } }
private void Line_MouseLeftButtonUp(object sender, MouseButtonEventArgs e) { if (trackingPointMouseMove) { FrameworkElement element = e.OriginalSource as FrameworkElement; SetImageSourcce(element, false); if (element != null) { this.Fill(Colors.Green, 1); element.Cursor = Cursors.Arrow; element.ReleaseMouseCapture(); } if (pointHadActualMove == true) { plShadow.Points = GetPloyline(plShadow.Points, mousePosition, e.GetPosition(this._cnsParent)); PointCollection points = new PointCollection(); for (int i = 0; i < plShadow.Points.Count; i++) { points.Add(new Point(plShadow.Points[i].X + this._ShadowX + this._startLocation.X + this._container.SimpleShapeLeft, plShadow.Points[i].Y + this._ShadowY + this._startLocation.Y)); } if (this.BeginElement != null || this.EndElement != null) { Point pBegin, pEnd; PointCollection points2 = new PointCollection(); if (this.BeginElement != null) { this.BeginElementHotspot = ((IControlBase)this.BeginElement).GetNearHotspot(points[0]); pBegin = ((IControlBase)this.BeginElement).GetHotspot(this.BeginElementHotspot); ((IControlBase)this.BeginElement).SetUnFocus(); this.BeginElement = null; } else pBegin = points[0]; if (this.EndElement != null) { this.EndElementHotspot = ((IControlBase)this.EndElement).GetNearHotspot(points[1]); pEnd = ((IControlBase)this.EndElement).GetHotspot(this.EndElementHotspot); ((IControlBase)this.EndElement).SetUnFocus(); this.EndElement = null; } else pEnd = points[1]; points2.Add(pBegin); points2.Add(points[1]); points2.Add(pEnd); points.Clear(); for (int i = 0; i < points2.Count; i++) points.Add(points2[i]); } this._container.CreateElement(this.Type, points); e.Handled = true; pointHadActualMove = false; } if (mousePosition != originalPosition) { PointCollection points = this.GetMe(); this.ShowShadow(points); } trackingPointMouseMove = false; } plShadow.Visibility = Visibility.Collapsed; }
public void gestureCompleted() { // Minimum number of frames of no motion to be segmented as a gesture int motion_threshold = 3; //originally 5 // Minimum length of time after a gesture is completed before another gesture can be started. int ignore_threshold = 10; // If users are still reseting their hands, ignore all the movements and clear all buffers. if (ignoreFrames <= ignore_threshold) { motion_free = 0; readyforgesture = false; colorBox.Background = new SolidColorBrush(Colors.Red); gesture_started = false; //Clear the buffers foreach (List<int> sublist in history) sublist.Clear(); foreach (List<int> sublist in inverse_history) sublist.Clear(); pointHist.Clear(); } if (gesture_started && ignoreFrames > ignore_threshold && motion_free > motion_threshold && selectedChannels >= 2) { // Use LINQ to remove all the frames at the end that correspond to the motion free periods. pointHist = new PointCollection(pointHist.Reverse().Skip(motion_threshold).Reverse()); S = new StylusPointCollection(S.Reverse().Skip(motion_threshold).Reverse()); for (int i = 0; i < history.Count; i++) { history[i] = new List<int>(history[i].Reverse<int>().Skip(motion_threshold).Reverse<int>()); inverse_history[i] = new List<int>(inverse_history[i].Reverse<int>().Skip(motion_threshold).Reverse<int>()); } //If we are in detect mode, pass it to WEKA for classification. if (detectMode.IsChecked.Value && pointHist.Count > 9) { //Call function to find features and test with weka machine if (selectedChannels == 2) { float[] speakers = { (float)KF[0].speakerTheta, (float)KF[1].speakerTheta }; //temp stores the string identifier of the gesture string temp = WekaHelper.Classify(false, pointHist.Count() * waveIn.BufferMilliseconds, true, new List<float>(speakers), pointHist, S, history, inverse_history); //switch statement to rename up/down gestures to forward/back when displaying in the application switch (temp) { case "swipe_up": temp = "swipe_forward"; break; case "swipe_down": temp = "swipe_back"; break; case "tap_up": temp = "tap_forward"; break; case "tap_down": temp = "tap_back"; break; } gestureDetected.Text = temp; //TODO Put interaction with other applications in this switch statement // Allows for changing between workspaces in windows 10. if (shellIntegration.IsChecked.Value) { switch (temp) { case "swipe_forward": sim.Keyboard.KeyDown(VirtualKeyCode.LWIN); sim.Keyboard.KeyPress(VirtualKeyCode.TAB); sim.Keyboard.KeyUp(VirtualKeyCode.LWIN); break; case "swipe_back": break; case "swipe_left": if (!chrome) { sim.Keyboard.KeyDown(VirtualKeyCode.LWIN); sim.Keyboard.KeyDown(VirtualKeyCode.LCONTROL); sim.Keyboard.KeyPress(VirtualKeyCode.LEFT); sim.Keyboard.KeyUp(VirtualKeyCode.LWIN); sim.Keyboard.KeyUp(VirtualKeyCode.LCONTROL); } else { sim.Keyboard.KeyDown(VirtualKeyCode.LCONTROL); sim.Keyboard.KeyDown(VirtualKeyCode.LSHIFT); sim.Keyboard.KeyPress(VirtualKeyCode.TAB); sim.Keyboard.KeyUp(VirtualKeyCode.LSHIFT); sim.Keyboard.KeyUp(VirtualKeyCode.LCONTROL); } break; case "swipe_right": if (!chrome) { sim.Keyboard.KeyDown(VirtualKeyCode.LWIN); sim.Keyboard.KeyDown(VirtualKeyCode.LCONTROL); sim.Keyboard.KeyPress(VirtualKeyCode.RIGHT); sim.Keyboard.KeyUp(VirtualKeyCode.LWIN); sim.Keyboard.KeyUp(VirtualKeyCode.LCONTROL); } else { sim.Keyboard.KeyDown(VirtualKeyCode.LCONTROL); sim.Keyboard.KeyPress(VirtualKeyCode.TAB); sim.Keyboard.KeyUp(VirtualKeyCode.LCONTROL); } break; case "tap_forward": chrome = true; break; case "tap_back": chrome = false; break; case "tap_left": break; case "tap_right": break; } } } ignoreFrames = 0; } // Clear the buffers foreach (List<int> sublist in history) sublist.Clear(); foreach (List<int> sublist in inverse_history) sublist.Clear(); pointHist.Clear(); // Prepare for next gesture (might need a button press) readyforgesture = false; colorBox.Background = new SolidColorBrush(Colors.Red); gesture_started = false; motion_free = 0; } }