added Revit 2022 SDK minus except *rvt and *rfa

2026-08-30 16:42:51 +00:00 · 2021-04-20 11:36:21 +02:00
parent 1133a82dc5
commit 7e327986e8
3034 changed files with 1245318 additions and 0 deletions
@@ -0,0 +1,434 @@
+//
+// (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 System.Drawing;
+using System.Drawing.Drawing2D;
+
+using Autodesk.Revit.DB.Structure;
+using Autodesk.Revit.DB;
+
+namespace Revit.SDK.Samples.InPlaceMembers.CS
+{
+    /// <summary>
+    /// trigger when view data updated
+    /// </summary>
+    public delegate void UpdateViewDelegate();
+
+    /// <summary>
+    /// interface as the datasource of view, include nececessary members
+    /// </summary>
+    public interface IGraphicsData
+    {
+        /// <summary>
+        /// 2D lines
+        /// </summary>
+        /// <returns></returns>
+        List<PointF[]> PointCurves();
+
+        /// <summary>
+        /// view data update
+        /// </summary>
+        event UpdateViewDelegate UpdateViewEvent;
+
+        /// <summary>
+        /// region of 3D view data
+        /// </summary>
+        RectangleF Region
+        {
+            get;
+        }
+    }
+
+    /// <summary>
+    /// abstract class include general members
+    /// </summary>
+    public abstract class GraphicsDataBase:IGraphicsData
+    {
+        /// <summary>
+        ///3D max point after transfered 
+        /// </summary>
+        protected Autodesk.Revit.DB.XYZ m_transferedMax;    
+
+        /// <summary>
+        ///3D min point after transfered 
+        /// </summary>
+        protected Autodesk.Revit.DB.XYZ m_transferedMin;    
+
+        /// <summary>
+        /// origin max define
+        /// </summary>
+        protected Autodesk.Revit.DB.XYZ m_originMax = new Autodesk.Revit.DB.XYZ (double.MinValue, double.MinValue, double.MinValue);    
+
+        /// <summary>
+        /// origin min define
+        /// </summary>
+        protected Autodesk.Revit.DB.XYZ m_originMin = new Autodesk.Revit.DB.XYZ (double.MaxValue, double.MaxValue, double.MaxValue);
+
+        /// <summary>
+        /// origin define
+        /// </summary>
+        protected double[,] m_origin = {{ 1.0, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }, { 0.0, 0.0, 1.0 } };
+
+        /// <summary>
+        ///minimum value of the region box's edge 
+        /// </summary>
+        public const float MINEDGElENGTH = 1.0f;
+
+        /// <summary>
+        /// default angle when rotate around X,Y,Z axis
+        /// </summary>
+        public const double ROTATEANGLE = System.Math.PI / 90;    
+
+        /// <summary>
+        /// update view event
+        /// </summary>
+        public virtual event UpdateViewDelegate UpdateViewEvent;
+        
+        /// <summary>
+        /// constructor
+        /// </summary>
+        public GraphicsDataBase()
+        {
+            Initialize();
+        }
+
+        /// <summary>
+        /// initialize some member data
+        /// </summary>
+        protected virtual void Initialize()
+        {    
+            double INITANGLE = Math.PI / 4;
+
+            RotateX(ref m_origin, INITANGLE);
+            RotateY(ref m_origin, INITANGLE);
+            m_transferedMax = new Autodesk.Revit.DB.XYZ (double.MinValue, double.MinValue, double.MinValue);
+            m_transferedMin = new Autodesk.Revit.DB.XYZ (double.MaxValue, double.MaxValue, double.MaxValue);
+        }
+
+        /// <summary>
+        /// trigger updata view event
+        /// </summary>
+        public virtual void UpdataData()
+        {
+            UpdateViewEvent();
+        }
+
+        /// <summary>
+        /// point curves function
+        /// </summary>
+        /// <returns>the points list of curves</returns>
+        public abstract List<PointF[]> PointCurves();
+
+        /// <summary>
+        /// rectangular region of 3D view data
+        /// </summary>
+        public RectangleF Region
+        {
+            get
+            {
+                float width = (float)(m_transferedMax.X - m_transferedMin.X);
+                float height = (float)(m_transferedMax.Y - m_transferedMin.Y);
+
+                float maxX = (width / 2);
+                float maxY = (height / 2);
+                float minX = -(width / 2);
+                float minY = -(height / 2);
+
+                if (width < 1)
+                {
+                    width = 1;
+                }
+                if (height < 1)
+                {
+                    height = 1;
+                }
+
+                RectangleF rec = new RectangleF(minX, minY, width, height);
+                return rec;
+            }
+        }
+
+        /// <summary>
+        /// rotate around Z axis with default angle
+        /// </summary>
+        /// <param name="direction">minus or positive angle</param>
+        public void RotateZ(bool direction)
+        {
+            double angle = ROTATEANGLE;
+            if (!direction)
+            {
+                angle = -ROTATEANGLE;
+            }
+
+            RotateZ(ref m_origin, angle);
+            UpdataData();
+        }
+
+        /// <summary>
+        /// rotate 3*3 matrix around Z axis 
+        /// </summary>
+        /// <param name="origin">matrix to rotate</param>
+        /// <param name="angle"></param>
+        private void RotateZ(ref double[,] origin, double angle)
+        {
+            double sin = Math.Sin(angle);
+            double cos = Math.Cos(angle);
+
+            double[,] rotate = { { cos, sin, 0.0 }, { -sin, cos, 0.0 }, { 0.0, 0.0, 1.0 } };
+            origin = MatrixArith.MultiCross(m_origin, rotate);
+        }
+
+        /// <summary>
+        /// rotate around Y axis with default angle
+        /// </summary>
+        /// <param name="direction">minus or positive angle</param>
+        public void RotateY(bool direction)
+        {
+            double angle = ROTATEANGLE;
+            if (!direction)
+            {
+                angle = -ROTATEANGLE;
+            }
+
+            RotateY(ref m_origin, angle);
+            UpdataData();
+        }
+
+        /// <summary>
+        /// rotate 3*3 matrix around Y axis 
+        /// </summary>
+        /// <param name="origin">matrix to rotate</param>
+        /// <param name="angle"></param>
+        private void RotateY(ref double[,] origin, double angle)
+        {
+            double sin = Math.Sin(angle);
+            double cos = Math.Cos(angle);
+
+            double[,] rotate = { { cos, 0.0, -sin }, { 0.0, 1.0, 0.0 }, { sin, 0.0, cos } };
+            origin = MatrixArith.MultiCross(m_origin, rotate);
+        }
+
+        /// <summary>
+        /// rotate around X axis with default angle
+        /// </summary>
+        /// <param name="direction">minus or positive angle</param>
+        public void RotateX(bool direction)
+        {
+            double angle = ROTATEANGLE;
+            if (!direction)
+            {
+                angle = -ROTATEANGLE;
+            }
+
+            RotateX(ref m_origin ,angle);
+            UpdataData();
+        }
+
+        /// <summary>
+        /// rotate 3*3 matrix around X axis 
+        /// </summary>
+        /// <param name="origin">matrix to rotate</param>
+        /// <param name="angle"></param>
+        private void RotateX(ref double[,] origin, double angle)
+        {
+            double sin = Math.Sin(angle);
+            double cos = Math.Cos(angle);
+
+            double[,] rotate = { { 1.0, 0.0, 0.0 }, { 0.0, cos, sin }, { 0.0, -sin, cos } };
+            origin = MatrixArith.MultiCross(m_origin, rotate);
+        }
+    }
+
+    /// <summary>
+    /// datasource that can bind to PictureBox3D
+    /// </summary>
+    public class GraphicsData : GraphicsDataBase
+    {
+        List<List<XYZ>> m_originCurves;
+        List<List<XYZ>> m_transferedCurves;
+        List<PointF[]> m_curves2D;
+
+        /// <summary>
+        /// update view event
+        /// </summary>
+        public override event UpdateViewDelegate UpdateViewEvent;
+
+        /// <summary>
+        /// constructor to initialize member data
+        /// </summary>
+        public GraphicsData() : base()
+        {
+            m_originCurves = new List<List<XYZ>>();
+            m_transferedCurves = new List<List<XYZ>>();
+            m_curves2D = new List<PointF[]>();
+        }
+
+        /// <summary>
+        /// curves array
+        /// </summary>
+        /// <returns></returns>
+        public override List<PointF[]> PointCurves()
+        {
+            return m_curves2D;
+        }
+
+        /// <summary>
+        /// insert curves array into datasource
+        /// </summary>
+        /// <param name="points">points compose the curve</param>
+        public void InsertCurve(List<XYZ> points)
+        {
+            m_originCurves.Add(points);
+            foreach (Autodesk.Revit.DB.XYZ point in points)
+            {
+                m_originMin = UpdateMinRange(point);
+                m_originMax = UpdateMaxRange(point);
+            }
+        }
+
+        /// <summary>
+        /// update 3D view data
+        /// </summary>
+        public override void UpdataData()
+        {
+            m_transferedMin = TransferRotate(m_originMin);
+            m_transferedMax = TransferRotate(m_originMax);    
+        
+            m_transferedCurves.Clear();
+            m_curves2D.Clear();
+
+            foreach (List<XYZ> points in m_originCurves)
+            {
+                SynChroData(points);
+            }
+
+            if (null != UpdateViewEvent)
+            {
+                UpdateViewEvent();
+            }
+        }
+
+        /// <summary>
+        /// update 3D view curve data with origin data and transfer matrix
+        /// </summary>
+        /// <param name="points"></param>
+        private void SynChroData(List<XYZ> points)
+        {
+            int size = points.Count;
+            PointF[] points2D = new PointF[size];
+            List<XYZ> transferedPoints = new List<XYZ>();
+            for(int i = 0; i<size;i++)
+            {
+                Autodesk.Revit.DB.XYZ point = points[i];
+                Autodesk.Revit.DB.XYZ temp = TransferRotate(point);
+                Autodesk.Revit.DB.XYZ transferedPoint = TransferMove(temp);
+                points2D[i] = new PointF((float)transferedPoint.X, (float)transferedPoint.Y);
+            }
+            m_transferedCurves.Add(transferedPoints);
+            m_curves2D.Add(points2D);
+        }
+
+        private XYZ UpdateMaxRange(XYZ pnt)
+        {
+            return new XYZ(
+                pnt.X > m_originMax.X ? pnt.X : m_originMax.X,
+                pnt.Y > m_originMax.Y ? pnt.Y : m_originMax.Y,
+                pnt.Z > m_originMax.Z ? pnt.Z : m_originMax.Z);
+        }
+
+        private XYZ UpdateMinRange(XYZ pnt)
+        {
+            return new XYZ(
+                pnt.X < m_originMin.X ? pnt.X : m_originMin.X,
+                pnt.Y < m_originMin.Y ? pnt.Y : m_originMin.Y,
+                pnt.Z < m_originMin.Z ? pnt.Z : m_originMin.Z);
+        }
+
+
+        /// <summary>
+        /// rotate points with origion matrix
+        /// </summary>
+        /// <param name="point"></param>
+        /// <returns></returns>
+        private Autodesk.Revit.DB.XYZ TransferRotate(Autodesk.Revit.DB.XYZ point)
+        {
+            double x = point.X;
+            double y = point.Y;
+            double z = point.Z;
+
+            return new XYZ(
+                x * m_origin[0, 0] + y * m_origin[0, 1] + z * m_origin[0, 2],
+                x * m_origin[1, 0] + y * m_origin[1, 1] + z * m_origin[1, 2],
+                x * m_origin[2, 0] + y * m_origin[2, 1] + z * m_origin[2, 2]);
+
+        }
+
+        /// <summary>
+        /// move the point so that the center of the curves in 3D view is origin
+        /// </summary>
+        /// <param name="point">points to be moved</param>
+        /// <returns>moved result</returns>
+        private Autodesk.Revit.DB.XYZ TransferMove(Autodesk.Revit.DB.XYZ point)
+        {
+            //transform the origin of the old coordinate system in the new coordinate system
+            
+            return new XYZ(
+                point.X - (m_transferedMax.X + m_transferedMin.X) / 2,
+                point.Y - (m_transferedMax.Y + m_transferedMin.Y) / 2,
+                point.Z - (m_transferedMax.Z + m_transferedMin.Z) / 2);
+        }
+    }
+
+    /// <summary>
+    /// utility class provide arithmetic of matrix
+    /// </summary>
+    public class MatrixArith
+    {
+        /// <summary>
+        /// multiply cross two matrix
+        /// </summary>
+        /// <param name="m1">left matrix</param>
+        /// <param name="m2">right matrix</param>
+        /// <returns>result matrix</returns>
+        public static double[,] MultiCross(double[,] m1, double[,] m2)
+        {
+            double[,] result = new double[3, 3];
+
+            for (int i = 0; i < 3; i++)
+            {
+                for (int j = 0; j < 3; j++)
+                {
+                    for (int k = 0; k < 3; k++)
+                    {
+                        result[i, j] += m1[i, k] * m2[k, j];
+                    }                    
+                }
+            }
+
+            return result;
+        }
+    }
+}