added Revit 2022 SDK minus except *rvt and *rfa

SDK/Samples/NewPathReinforcement/CS/Profile.cs

@@ -0,0 +1,291 @@
+//
+// (C) Copyright 2003-2019 by Autodesk, Inc.
+//
+// Permission to use, copy, modify, and distribute this software in
+// object code form for any purpose and without fee is hereby granted,
+// provided that the above copyright notice appears in all copies and
+// that both that copyright notice and the limited warranty and
+// restricted rights notice below appear in all supporting
+// documentation.
+//
+// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
+// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
+// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE. AUTODESK, INC.
+// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
+// UNINTERRUPTED OR ERROR FREE.
+//
+// Use, duplication, or disclosure by the U.S. Government is subject to
+// restrictions set forth in FAR 52.227-19 (Commercial Computer
+// Software - Restricted Rights) and DFAR 252.227-7013(c)(1)(ii)
+// (Rights in Technical Data and Computer Software), as applicable.
+//
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Autodesk.Revit.DB;
+using Autodesk.Revit.UI;
+using Autodesk.Revit.DB.Structure;
+using Autodesk.Revit;
+using System.Drawing;
+using Point = System.Drawing.Point;
+
+namespace Revit.SDK.Samples.NewPathReinforcement.CS
+{
+   /// <summary>
+   /// base class of ProfileFloor and ProfileWall
+   /// contains the profile information and can make matrix to transform point to 2D plane
+   /// </summary>
+   public abstract class Profile
+   {
+      #region class member variables
+      /// <summary>
+      /// store all the points on the needed face
+      /// </summary>
+      protected List<List<XYZ>> m_points;
+
+      /// <summary>
+      /// object which contains reference to Revit Application
+      /// </summary>
+      protected Autodesk.Revit.UI.ExternalCommandData m_commandData;
+
+      /// <summary>
+      /// used to create new instances of utility objects. 
+      /// </summary>
+      protected Autodesk.Revit.Creation.Application m_appCreator;
+
+      /// <summary>
+      /// Revit DB document
+      /// </summary>
+      protected Autodesk.Revit.DB.Document m_document;
+
+      /// <summary>
+      /// store the Matrix used to transform 3D points to 2D
+      /// </summary>
+      protected Matrix4 m_to2DMatrix = null;
+      #endregion
+
+      /// <summary>
+      /// CommandData property get object which contains reference to Revit Application
+      /// </summary>
+      public Autodesk.Revit.UI.ExternalCommandData CommandData
+      {
+         get
+         {
+            return m_commandData;
+         }
+      }
+
+      /// <summary>
+      /// To2DMatrix property to get Matrix used to transform 3D points to 2D
+      /// </summary>
+      public Matrix4 To2DMatrix
+      {
+         get
+         {
+            return m_to2DMatrix;
+         }
+      }
+
+      /// <summary>
+      /// constructor
+      /// </summary>
+      /// <param name="commandData">object which contains reference to Revit Application</param>
+      protected Profile(ExternalCommandData commandData)
+      {
+         m_commandData = commandData;
+         m_appCreator = m_commandData.Application.Application.Create;
+         m_document = m_commandData.Application.ActiveUIDocument.Document;
+      }
+
+      /// <summary>
+      /// abstract method to create PathReinforcement
+      /// </summary>
+      /// <returns>new created PathReinforcement</returns>
+      /// <param name="points">points used to create PathReinforcement</param>
+      /// <param name="flip">used to specify whether new PathReinforcement is Filp</param>
+      public abstract PathReinforcement CreatePathReinforcement(List<Vector4> points, bool flip);
+
+      /// <summary>
+      /// Get points in first face
+      /// </summary>
+      /// <param name="faces">edges in all faces</param>
+      /// <returns>points in first face</returns>
+      public abstract List<List<XYZ>> GetNeedPoints(List<List<Edge>> faces);
+
+      /// <summary>
+      /// Get a matrix which can transform points to 2D
+      /// </summary>
+      public abstract Matrix4 GetTo2DMatrix();
+
+      /// <summary>
+      /// draw profile of wall or floor in 2D
+      /// </summary>
+      /// <param name="graphics">form graphic</param>
+      /// <param name="pen">pen used to draw line in pictureBox</param>
+      /// <param name="matrix4">Matrix used to transform 3d to 2d 
+      /// and make picture in right scale </param>
+      public void Draw2D(Graphics graphics, Pen pen, Matrix4 matrix4)
+      {
+         for (int i = 0; i < m_points.Count; i++)
+         {
+            List<XYZ> points = m_points[i];
+            for (int j = 0; j < points.Count - 1; j++)
+            {
+               Autodesk.Revit.DB.XYZ point1 = points[j];
+               Autodesk.Revit.DB.XYZ point2 = points[j + 1];
+
+               Vector4 v1 = new Vector4(point1);
+               Vector4 v2 = new Vector4(point2);
+
+               v1 = matrix4.Transform(v1);
+               v2 = matrix4.Transform(v2);
+               graphics.DrawLine(pen, new Point((int)v1.X, (int)v1.Y),
+                   new Point((int)v2.X, (int)v2.Y));
+            }
+         }
+      }
+
+      /// <summary>
+      /// Get edges of element's profile
+      /// </summary>
+      /// <param name="elem">selected element</param>
+      /// <returns>all the faces in the selected Element</returns>
+      public List<List<Edge>> GetFaces(Autodesk.Revit.DB.Element elem)
+      {
+         List<List<Edge>> faceEdges = new List<List<Edge>>();
+         Options options = m_appCreator.NewGeometryOptions();
+         options.DetailLevel = ViewDetailLevel.Medium;
+         options.ComputeReferences = true; //make sure references to geometric objects are computed.
+         Autodesk.Revit.DB.GeometryElement geoElem = elem.get_Geometry(options);
+         //GeometryObjectArray gObjects = geoElem.Objects;
+         IEnumerator<GeometryObject> Objects = geoElem.GetEnumerator();
+         //get all the edges in the Geometry object
+         //foreach (GeometryObject geo in gObjects)
+         while (Objects.MoveNext())
+         {
+            GeometryObject geo = Objects.Current;
+
+            Solid solid = geo as Solid;
+            if (solid != null)
+            {
+               FaceArray faces = solid.Faces;
+               foreach (Face face in faces)
+               {
+                  EdgeArrayArray edgeArrarr = face.EdgeLoops;
+                  foreach (EdgeArray edgeArr in edgeArrarr)
+                  {
+                     List<Edge> edgesList = new List<Edge>();
+                     foreach (Edge edge in edgeArr)
+                     {
+                        edgesList.Add(edge);
+                     }
+                     faceEdges.Add(edgesList);
+                  }
+               }
+            }
+         }
+         return faceEdges;
+      }
+
+      /// <summary>
+      /// Get normal of face
+      /// </summary>
+      /// <param name="face">edges in a face</param>
+      /// <returns>vector stands for normal of the face</returns>
+      public Vector4 GetFaceNormal(List<Edge> face)
+      {
+         Edge eg0 = face[0];
+         Edge eg1 = face[1];
+
+         //get two lines from the face
+         List<XYZ> points = eg0.Tessellate() as List<XYZ>;
+         Autodesk.Revit.DB.XYZ start = points[0];
+         Autodesk.Revit.DB.XYZ end = points[1];
+
+         Vector4 vStart = new Vector4((float)start.X, (float)start.Y, (float)start.Z);
+         Vector4 vEnd = new Vector4((float)end.X, (float)end.Y, (float)end.Z);
+         Vector4 vSub = vEnd - vStart;
+
+         points = eg1.Tessellate() as List<XYZ>;
+         start = points[0];
+         end = points[1];
+
+         vStart = new Vector4((float)start.X, (float)start.Y, (float)start.Z);
+         vEnd = new Vector4((float)end.X, (float)end.Y, (float)end.Z);
+         Vector4 vSub2 = vEnd - vStart;
+
+         //get the normal with two lines got from face
+         Vector4 result = vSub.CrossProduct(vSub2);
+         result.Normalize();
+         return result;
+      }
+
+      /// <summary>
+      /// Get a matrix which can move points to center
+      /// </summary>
+      /// <returns>matrix used to move point to center of graphics</returns>
+      public Matrix4 ToCenterMatrix()
+      {
+         //translate the origin to bound center
+         PointF[] bounds = GetFaceBounds();
+         PointF min = bounds[0];
+         PointF max = bounds[1];
+         PointF center = new PointF((min.X + max.X) / 2, (min.Y + max.Y) / 2);
+         return new Matrix4(new Vector4(center.X, center.Y, 0));
+      }
+
+      /// <summary>
+      /// Get the bound of a face
+      /// </summary>
+      /// <returns>points array store the bound of the face</returns>
+      public PointF[] GetFaceBounds()
+      {
+         Matrix4 matrix = m_to2DMatrix;
+         Matrix4 inverseMatrix = matrix.Inverse();
+         float minX = 0, maxX = 0, minY = 0, maxY = 0;
+         bool bFirstPoint = true;
+
+         //get the max and min point on the face
+         for (int i = 0; i < m_points.Count; i++)
+         {
+            List<XYZ> points = m_points[i];
+            foreach (Autodesk.Revit.DB.XYZ point in points)
+            {
+               Vector4 v = new Vector4(point);
+               Vector4 v1 = inverseMatrix.Transform(v);
+
+               if (bFirstPoint)
+               {
+                  minX = maxX = v1.X;
+                  minY = maxY = v1.Y;
+                  bFirstPoint = false;
+               }
+               else
+               {
+                  if (v1.X < minX)
+                  {
+                     minX = v1.X;
+                  }
+                  else if (v1.X > maxX)
+                  {
+                     maxX = v1.X;
+                  }
+
+                  if (v1.Y < minY)
+                  {
+                     minY = v1.Y;
+                  }
+                  else if (v1.Y > maxY)
+                  {
+                     maxY = v1.Y;
+                  }
+               }
+            }
+         }
+         //return an array with max and min value of face
+         PointF[] resultPoints = new PointF[2] { 
+                new PointF(minX, minY), new PointF(maxX, maxY) };
+         return resultPoints;
+      }
+   }
+}