[레빗 API 시작하기] Revit Family Lab2 - Create L-Shape Column_CS

Revit Family Lab2 - Create L-Shape Column_CS

Family Lab2 - Create L-Shape Column_CS_번역.docx

이번 LAB에서는 ㄴ자형태의 기둥 패밀리를 제작하는 과정입니다.

Lab1과정에서 추가되는 항목은 2개의 면에 대한 참조평면을 작성하는 것과 정렬할때 추가참조면에 정렬하는 방법을 학습할 것입니다.

파라미터를 생성하고 치수를 만들어서 파라미터를 적용하는 방법을 학습할 것입니다.

1. 외부명령을 정의

2. 패밀리를 제작할 수 있는 문서의 유효성을 확인

3. 추가적을 필요한 참조평명를 추가하기

4. L자형의 프로파일을 만들어서 솔리드모델을 생성

5. 솔리드 도델을 참조면에 정렬하여 구속하기

6. 매개변수 추가하기

7. 치수를 만들어 매개변수 적용하기

8. 타입을 추가하기

기둥패밀리의 "Metric Column.rft"을 열어야 실행이 가능합니다.

Class

RvtCmd_FamilyCreateColumnLShape - L자형 기둥패밀리를 만드는 클래스

Field

RvApp - 응용프로그램의 멤버변수

RvDoc - 작업하는 문서의 멤버변수

Method

// IExternalCommand 함수를 상속받아서 클래스를 시작하기

Execute(ExternalCommandData, string, ElementSet)

// Metric Column.rft 템플릿 파일에서 작업하는 확인하기

isRightTemplate(BuiltInCategory)

// L자형에 해당하는 참조면 2개 만들기

addReferencePlanes()

// mm단위로 입력된 값을 피트단위로 변경

mmToFeet(double) // 도움함수

// L자형 기둥에 해당하는 솔리드 모델 만들기

createSolid()

// mm단위로 입력된 값을 피트단위로 변경

mmToFeet(double) // 도움함수

// L자형의 프로파일 만들기

createProfileLShape()

// mm단위로 입력된 값을 피트단위로 변경

mmToFeet(double) // 도움함수

// 미적용: 직사각형 프로파일 만들기

createProfileRectangle()

// mm단위로 입력된 값을 피트단위로 변경

mmToFeet(double) // 도움함수

// 생성된 솔리드의 면을 참조면에 맟추어서 정렬

addAlignments(Extrusion)

// 참조면에서 객체의 기준좌표와 일치하는 면을 찾기

findFace(Extrusion, XYZ, ReferencePlane) // 도움함수

// 객체의 기준좌표와 일치하는 면을 찾기

findFace(Extrusion, XYZ) // 도움함수

// 해당되는 타입의 뷰이름과 일치하는 요소를 찾기

findElement(Type, string)

// 두께에 해당하는 파라미터 생성

addParameters()

// mm단위로 입력된 값을 피트단위로 변경

mmToFeet(double) // 도움함수

// 두께에 해당하는 치수를 작성하고 생선된 파라미터 적용하기

addDimensions()

// 기둥의 크기에 대한 유형을 입력하기

addTypes()

// 유형이름, 폭, 너비, 두께를 입력받아 새로운 유형을 만들기

addType(string, double, double, double, double)

// mm단위로 입력된 값을 피트단위로 변경

mmToFeet(double) // 도움함수

// 미적용: 유형이름, 폭, 너비를 입력받아 새로운 유형을 만들기

addType(string, double, double)

// mm단위로 입력된 값을 피트단위로 변경

mmToFeet(double) // 도움함수

// 미적용: 입력된 파리미터 값을 수정

modifyFamilyParamValue() 

using System;
using System.Collections.Generic;
using System.Linq; // in System.Core 
using Autodesk.Revit;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI;
using Autodesk.Revit.ApplicationServices;

namespace FamilyCs
{
  [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Automatic)]

  // 메소드 구문: IExternalCommand의 값을 상속받는 클래스 시작
  class RvtCmd_FamilyCreateColumnLShape : IExternalCommand
  {
    // 멤버 변수명 정의
    Application RvApp;
    Document RvDoc;

    // 구문의 시작
    public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
    {
      // commandData의 값을 이용하여 멤버변수에 값을 입력
      RvApp = commandData.Application.Application;
      RvDoc = commandData.Application.ActiveUIDocument.Document;

      // 기둥패밀리 작업을 시작할수있는 문서인지 확인하기  Metric Column.rft 파일인지 체크함.
      if (!isRightTemplate(BuiltInCategory.OST_Columns))
      {
        Util.ErrorMsg("Please open Metric Column.rft");
        return Result.Failed;
      }

      // L자형에 해당하는 참조면 2개 만들기
      addReferencePlanes();

      // L자형 기둥에 해당하는 솔리드 모델 만들기
      Extrusion pSolid = createSolid();
      RvDoc.Regenerate();

      // 생성된 솔리드의 면을 참조면에 맟추어서 정렬
      addAlignments(pSolid);

      // 두께에 해당하는 파라미터 생성
      addParameters();

      // 두께에 해당하는 치수를 작성하고 생선된 파라미터 적용하기
      addDimensions();

      // 기둥의 크기에 대한 유형을 입력하기
      addTypes();

      // 미적용: 입력된 파리미터 값을 수정 테스트 하기 위한 구문
      //modifyFamilyParamValue();


      return Result.Succeeded;
    }
    
    // 메소드 구문: 기둥패밀리 작업을 시작할수있는 문서인지 확인하기
    bool isRightTemplate(BuiltInCategory targetCategory)
    {
      // 패밀리 템플릿인지 체크
      if (!RvDoc.IsFamilyDocument)
      {
        Util.ErrorMsg("This command works only in the family editor.");
        return false;
      }

      // 패밀리 문맥인지 카테고리가 기둥인 체크하기
      Category cat = RvDoc.Settings.Categories.get_Item(targetCategory);
      if (RvDoc.OwnerFamily == null)
      {
        Util.ErrorMsg("This command only works in the family context.");
        return false;
      }
      if (!cat.Id.Equals(RvDoc.OwnerFamily.FamilyCategory.Id))
      {
        Util.ErrorMsg("Category of this family document does not match the context required by this command.");
        return false;
      }

      // 체크사항에 정상이면 true을 리턴함.
      return true;
    }

    // 메소드 구문: L자형에 해당하는 참조면 2개 만들기
    void addReferencePlanes()
    {
      // L자형을 형성하기 위한 2개의 참조면 "OffsetH" "OffsetV" 추가하기
      double tw = mmToFeet(150.0);
      double td = mmToFeet(150.0);

      // "OffsetH" 참조평면 만들기
      // 하부 평면 뷰 가져오기
      View pViewPlan = findElement(typeof(ViewPlan), "Lower Ref. Level") as View;

      // 정면 참조평면 가져오기
      ReferencePlane refFront = findElement(typeof(ReferencePlane), "Front") as ReferencePlane;

      // 정면 참조면에서 두께 거리로 이격된 두개의 좌표값 구하기
      XYZ p1 = refFront.BubbleEnd;
      XYZ p2 = refFront.FreeEnd;
      XYZ pBubbleEnd = new XYZ(p1.X, p1.Y + td, p1.Z);
      XYZ pFreeEnd = new XYZ(p2.X, p2.Y + td, p2.Z);

      // 좌표값으로 "OffsetH" 참조평면 만들기
      ReferencePlane refPlane = RvDoc.FamilyCreate.NewReferencePlane(pBubbleEnd, pFreeEnd, XYZ.BasisZ, pViewPlan);
      refPlane.Name = "OffsetH";

      // "OffsetV" 참조평면 만들기
      // 좌측 참조평면 가져오기
      ReferencePlane refLeft = findElement(typeof(ReferencePlane), "Left") as ReferencePlane;

      // 좌측 참조면에서 두께 거리로 이격된 두개의 좌표값 구하기
      p1 = refLeft.BubbleEnd;
      p2 = refLeft.FreeEnd;
      pBubbleEnd = new XYZ(p1.X + tw, p1.Y, p1.Z);
      pFreeEnd = new XYZ(p2.X + tw, p2.Y, p2.Z);

      // 좌표값으로 "OffsetV" 참조평면 만들기
      refPlane = RvDoc.FamilyCreate.NewReferencePlane(pBubbleEnd, pFreeEnd, XYZ.BasisZ, pViewPlan);
      refPlane.Name = "OffsetV";
    }

    // 메소드 구문: L자형 기둥에 해당하는 솔리드 모델 만들기
    Extrusion createSolid()
    {
      // L자형의 프로파일 만들기
      CurveArrArray pProfile = createProfileLShape();

      // 기둥 탬플릿의 하부레벨 참조평면 가져오기
      ReferencePlane pRefPlane = findElement(typeof(ReferencePlane), "Reference Plane") as ReferencePlane;
      // 하부레벨 참조평면을 작업레벨로 스케치평면 설정하기
      SketchPlane pSketchPlane = SketchPlane.Create(RvDoc, pRefPlane.Plane);

      // 돌출시킬 높이값 설정
      double dHeight = mmToFeet(4000.0);

      // 입력된 프로파일을 솔리드모델로 돌출
      bool bIsSolid = true;
      return RvDoc.FamilyCreate.NewExtrusion(bIsSolid, pProfile, pSketchPlane, dHeight);
    }

    // 메소드 구문: L자형의 프로파일 만들기
    CurveArrArray createProfileLShape()
    {
      // 프로파일 거리값을 설정
      double w = mmToFeet(600.0);
      double d = mmToFeet(600.0);
      double tw = mmToFeet(150.0);
      double td = mmToFeet(150.0);

      // 프로파일의 정점을 정의
      const int nVerts = 6; //6개 선형을 그리기 위한 반복횟수 설정

      XYZ[] pts = new XYZ[] {
        new XYZ(-w / 2.0, -d / 2.0, 0.0),
        new XYZ(w / 2.0, -d / 2.0, 0.0),
        new XYZ(w / 2.0, (-d / 2.0) + td, 0.0),
        new XYZ((-w / 2.0) + tw, (-d / 2.0) + td, 0.0),
        new XYZ((-w / 2.0) + tw, d / 2.0, 0.0),
        new XYZ(-w / 2.0, d / 2.0, 0.0),
        new XYZ(-w / 2.0, -d / 2.0, 0.0) };

      // 정점을 잇는 CurveArray 설정
      CurveArray pLoop = RvApp.Create.NewCurveArray();
      for (int i = 0; i < nVerts; ++i)
      {
        Line line = Line.CreateBound(pts[i], pts[i + 1]);
        pLoop.Append(line);
      }

      // CurveArray값을 프로파일의 CurveArrArray 입력
      CurveArrArray pProfile = RvApp.Create.NewCurveArrArray();
      pProfile.Append(pLoop);

      // 형성된 프로파일을 리턴
      return pProfile;
    }

    // 메소드 구문: 미적용: 직사각형 프로파일 만들기
    CurveArrArray createProfileRectangle()
    {
      // 프로파일 거리값을 설정
      double w = mmToFeet(600.0);
      double d = mmToFeet(600.0);

      // 프로파일의 정점을 정의
      const int nVerts = 4; //4개 선형을 그리기 위한 반복횟수 설정

      XYZ[] pts = new XYZ[] {
        new XYZ(-w / 2.0, -d / 2.0, 0.0),
        new XYZ(w / 2.0, -d / 2.0, 0.0),
        new XYZ(w / 2.0, d / 2.0, 0.0),
        new XYZ(-w / 2.0, d / 2.0, 0.0),
        new XYZ(-w / 2.0, -d / 2.0, 0.0) };

      // 정점을 잇는 CurveArray 설정
      CurveArray pLoop = RvApp.Create.NewCurveArray();
      for (int i = 0; i < nVerts; ++i)
      {
        Line line = Line.CreateBound(pts[i], pts[i + 1]);
        pLoop.Append(line);
      }

      // CurveArray값을 프로파일의 CurveArrArray 입력
      CurveArrArray pProfile = RvApp.Create.NewCurveArrArray();
      pProfile.Append(pLoop);

      // 형성된 프로파일을 리턴
      return pProfile;
    }

    // 메소드 구문: 생성된 솔리드의 면을 참조면에 맟추어서 정렬
    void addAlignments(Extrusion pBox)
    {
      // 솔리드의 상부면 정렬하기
      // 정면 뷰 가져오기
      View pView = findElement(typeof(View), "Front") as View;

      // 상부레벨 가져와서 참조평면으로 설정하여 ref1에 입력
      Level upperLevel = findElement(typeof(Level), "Upper Ref Level") as Level;
      Reference ref1 = upperLevel.PlaneReference;

      // 솔리드 모델의 상부면을 가져와서 참조로 설정하고 ref2에 입력
      PlanarFace upperFace = findFace(pBox, new XYZ(0.0, 0.0, 1.0)); // Z값이 상부인 면 찾기
      Reference ref2 = upperFace.Reference;

      // 정면뷰에서 ref2면을 ref1에 정렬시킴
      RvDoc.FamilyCreate.NewAlignment(pView, ref1, ref2);

      // 솔리드의 하부면 정렬하기
      // 하부레벨 가져와서 참조평면으로 설정하여 ref3에 입력
      Level lowerLevel = findElement(typeof(Level), "Lower Ref. Level") as Level;
      Reference ref3 = lowerLevel.PlaneReference;

      // 솔리드 모델의 하부면을 가져와서 참조로 설정하고 ref4에 입력
      PlanarFace lowerFace = findFace(pBox, new XYZ(0.0, 0.0, -1.0)); // Z값이 하부인 면 찾기
      Reference ref4 = lowerFace.Reference;

      // 정면뷰에서 ref4면을 ref3에 정렬시킴
      RvDoc.FamilyCreate.NewAlignment(pView, ref3, ref4);

      // 하부평면 뷰 가져오기
      View pViewPlan = findElement(typeof(ViewPlan), "Lower Ref. Level") as View;

      // 측면의 정렬시킬 참조평면 6개 변수 설정 - 4개(기본제공) 2개(addReferencePlanes 클래스에서 설정)
      ReferencePlane refRight = findElement(typeof(ReferencePlane), "Right") as ReferencePlane;
      ReferencePlane refLeft = findElement(typeof(ReferencePlane), "Left") as ReferencePlane;
      ReferencePlane refFront = findElement(typeof(ReferencePlane), "Front") as ReferencePlane;
      ReferencePlane refBack = findElement(typeof(ReferencePlane), "Back") as ReferencePlane;
      ReferencePlane refOffsetV = findElement(typeof(ReferencePlane), "OffsetV") as ReferencePlane;
      ReferencePlane refOffsetH = findElement(typeof(ReferencePlane), "OffsetH") as ReferencePlane;

      // 솔리드 모델의 각각의 측면을 변수에 입력
      PlanarFace faceRight = findFace(pBox, new XYZ(1.0, 0.0, 0.0), refRight);
      PlanarFace faceLeft = findFace(pBox, new XYZ(-1.0, 0.0, 0.0));
      PlanarFace faceFront = findFace(pBox, new XYZ(0.0, -1.0, 0.0));
      PlanarFace faceBack = findFace(pBox, new XYZ(0.0, 1.0, 0.0), refBack);
      PlanarFace faceOffsetV = findFace(pBox, new XYZ(1.0, 0.0, 0.0), refOffsetV);
      PlanarFace faceOffsetH = findFace(pBox, new XYZ(0.0, 1.0, 0.0), refOffsetH);

      // 하부평면 뷰에서 솔리드의 각가의 측면을 해당하는 참조평면에 정렬시킴
      RvDoc.FamilyCreate.NewAlignment(pViewPlan, refRight.Reference, faceRight.Reference);
      RvDoc.FamilyCreate.NewAlignment(pViewPlan, refLeft.Reference, faceLeft.Reference);
      RvDoc.FamilyCreate.NewAlignment(pViewPlan, refFront.Reference, faceFront.Reference);
      RvDoc.FamilyCreate.NewAlignment(pViewPlan, refBack.Reference, faceBack.Reference);
      RvDoc.FamilyCreate.NewAlignment(pViewPlan, refOffsetV.Reference, faceOffsetV.Reference);
      RvDoc.FamilyCreate.NewAlignment(pViewPlan, refOffsetH.Reference, faceOffsetH.Reference);
    }

    // 메소드 구문: 두께에 해당하는 파라미터 생성
    void addParameters()
    {
      FamilyManager mgr = RvDoc.FamilyManager;

      // 파라미터 생성하기 - 칫수에 대한 API 파라미터그룹은 PG_GEOMETRY 임.
      FamilyParameter paramTw = mgr.AddParameter("Tw", BuiltInParameterGroup.PG_GEOMETRY,ParameterType.Length, false);

      FamilyParameter paramTd = mgr.AddParameter("Td", BuiltInParameterGroup.PG_GEOMETRY,ParameterType.Length, false);

      // 초기값 설정하기
      double tw = mmToFeet(150.0);
      double td = mmToFeet(150.0);
      mgr.Set(paramTw, tw);
      mgr.Set(paramTd, td);
    }

    // 메소드 구문: 두께에 해당하는 치수를 작성하고 생선된 파라미터 적용하기
    void addDimensions()
    {
      // 하부평면 뷰 가져오기
      View pViewPlan = findElement(typeof(ViewPlan), "Lower Ref. Level") as View;

      // 치수를 적용할 참조평면 가져오기
      ReferencePlane refLeft = findElement(typeof(ReferencePlane), "Left") as ReferencePlane;
      ReferencePlane refFront = findElement(typeof(ReferencePlane), "Front") as ReferencePlane;
      ReferencePlane refOffsetV = findElement(typeof(ReferencePlane), "OffsetV") as ReferencePlane;
      ReferencePlane refOffsetH = findElement(typeof(ReferencePlane), "OffsetH") as ReferencePlane;

      // 참조평면  'Left' 'OffsetV' 사이에 칫수를 추가하고 라벨을 'Tw'로 설정하기
      // 칫수라인을 정의하기
      XYZ p0 = refLeft.FreeEnd;
      XYZ p1 = refOffsetV.FreeEnd;
      Line pLine = Line.CreateBound(p0, p1);

      // 참조를 정의하기
      ReferenceArray pRefArray = new ReferenceArray();
      pRefArray.Append(refLeft.Reference);
      pRefArray.Append(refOffsetV.Reference);

      // 칫수만들기
      Dimension pDimTw = RvDoc.FamilyCreate.NewDimension(pViewPlan, pLine, pRefArray);

      // 칫수에 라벨 추가하기
      FamilyParameter paramTw = RvDoc.FamilyManager.get_Parameter("Tw");
      pDimTw.FamilyLabel = paramTw;

      // 참조평면  'Front' 'OffsetH' 사이에 칫수를 추가하고 라벨을 'Td'로 설정하기
      // 칫수라인을 정의하기
      p0 = refFront.FreeEnd;
      p1 = refOffsetH.FreeEnd;
      //pLine = _app.Create.NewLineBound(p0, p1);  // Revit 2013
      pLine = Line.CreateBound(p0, p1);  // Revit 2014

      // 참조를 정의하기
      pRefArray = new ReferenceArray();
      pRefArray.Append(refFront.Reference);
      pRefArray.Append(refOffsetH.Reference);

      // 칫수만들기
      Dimension pDimTd = RvDoc.FamilyCreate.NewDimension(pViewPlan, pLine, pRefArray);

      // 칫수에 라벨 추가하기
      FamilyParameter paramTd = RvDoc.FamilyManager.get_Parameter("Td");
      pDimTd.FamilyLabel = paramTd;
    }

    // 메소드 구문: 기둥의 크기에 대한 유형을 입력하기
    void addTypes()
    {
      addType("600x900", 600.0, 900.0, 150.0, 225.0);
      addType("1000x300", 1000.0, 300.0, 250.0, 75.0);
      addType("600x600", 600.0, 600.0, 150.0, 150.0);
    }

    // 메소드 구문: 유형이름, 폭, 너비, 두께를 입력받아 새로운 유형을 만들기- Version 2
    void addType(string name, double w, double d, double tw, double td)
    {
      // 현재문서에서 family manager를 가져와서 변수에 입력하기
      FamilyManager pFamilyMgr = RvDoc.FamilyManager;

      // 주어진 이름으로 새로운 타입을 추가하여 type1 변수에 저장
      FamilyType type1 = pFamilyMgr.NewType(name);

      // paramW에 'Width'를 설정하고 주어진 값을 입력
      FamilyParameter paramW = pFamilyMgr.get_Parameter("Width");
      double valW = mmToFeet(w);
      if (paramW != null)
      {
        pFamilyMgr.Set(paramW, valW);
      }

      // paramD에 'Depth'를 설정하고 주어진 값을 입력
      FamilyParameter paramD = pFamilyMgr.get_Parameter("Depth");
      double valD = mmToFeet(d);
      if (paramD != null)
      {
        pFamilyMgr.Set(paramD, valD);
      }

      // paramTw에 'Tw'를 설정하고 주어진 값을 입력
      FamilyParameter paramTw = pFamilyMgr.get_Parameter("Tw");
      double valTw = mmToFeet(tw);
      if (paramTw != null)
      {
        pFamilyMgr.Set(paramTw, valTw);
      }

      // paramTd에 'Td'를 설정하고 주어진 값을 입력
      FamilyParameter paramTd = pFamilyMgr.get_Parameter("Td");
      double valTd = mmToFeet(td);
      if (paramTd != null)
      {
        pFamilyMgr.Set(paramTd, valTd);
      }
    }

    // 메소드 구문: 유형이름, 폭, 너비를 입력받아 새로운 유형을 만들기- Version 1
    void addType(string name, double w, double d)
    {
      // 현재문서에서 family manager를 가져와서 변수에 입력하기
      FamilyManager pFamilyMgr = RvDoc.FamilyManager;

      // 주어진 이름으로 새로운 타입을 추가하여 type1 변수에 저장
      FamilyType type1 = pFamilyMgr.NewType(name);

      // paramW에 'Width'를 설정하고 주어진 값을 입력
      FamilyParameter paramW = pFamilyMgr.get_Parameter("Width");
      double valW = mmToFeet(w);
      if (paramW != null)
      {
        pFamilyMgr.Set(paramW, valW);
      }

      // paramD에 'Depth'를 설정하고 주어진 값을 입력
      FamilyParameter paramD = pFamilyMgr.get_Parameter("Depth");
      double valD = mmToFeet(d);
      if (paramD != null)
      {
        pFamilyMgr.Set(paramD, valD);
      }
    }

    // 메소드 구문: 미적용: 입력된 파리미터 값을 수정 테스트 하기 위한 구문
    void modifyFamilyParamValue()
    {
      FamilyManager mgr = RvDoc.FamilyManager;

      FamilyParameter[] a = new FamilyParameter[] {
        mgr.get_Parameter( "Width" ),
        mgr.get_Parameter( "Depth" )
      };

      foreach (FamilyType t in mgr.Types)
      {
        mgr.CurrentType = t;
        foreach (FamilyParameter fp in a)
        {
          if (t.HasValue(fp))
          {
            double x = (double)t.AsDouble(fp);
            mgr.Set(fp, 2.0 * x);
          }
        }
      }
    }

    // 메소드 구문: 도움함수: 참조면에서 객체의 기준좌표와 일치하는 면을 찾기
    PlanarFace findFace(Extrusion pBox, XYZ normal, ReferencePlane refPlane)
    {
      // 주어진 요소의 형상객체를 가져와서 geomElem변수에 저장
      Options op = new Options();
      op.ComputeReferences = true;
      GeometryElement geomElem = pBox.get_Geometry(op);

      // 반복구문을 이용하여 주어진 기준점과 일치하는 면을 찾기
      foreach (GeometryObject geomObj in geomElem)
      {
        if (geomObj is Solid)  // geomObj의 객체가 solid이면 아래의 구문 실행
        {
          Solid pSolid = geomObj as Solid;
          FaceArray faces = pSolid.Faces;
          foreach (Face pFace in faces)
          {
            PlanarFace pPlanarFace = (PlanarFace)pFace;

            // 반복구문을 이용하여 선택된 면이 기준점과 일치하는 체크
            if ((pPlanarFace != null) && pPlanarFace.Normal.IsAlmostEqualTo(normal))
            {
              // 참조평면에 외곽을 형성
              XYZ p0 = refPlane.BubbleEnd;
              XYZ p1 = refPlane.FreeEnd;
              Line pCurve = Line.CreateBound(p0, p1); 

              // 참조평면에 있는면인지 검토하기
              if (pPlanarFace.Intersect(pCurve) == SetComparisonResult.Subset)
              {
                // 면을 찾았으면 면을 응답
                return pPlanarFace;
              }
            }
          }
        }

        // 필요에 따라서 나중에 사용이 될수 있는 구문 - 참조용
        //
        //else if (geomObj is Instance)
        //{
        //}
        //else if (geomObj is Curve)
        //{
        //}
        //else if (geomObj is Mesh)
        //{
        //}
      }

      // 찾지못하였으면 null을 응답
      return null;
    }

    // 메소드 구문: 도움함수: 객체의 기준좌표와 일치하는 면을 찾기
    PlanarFace findFace(Extrusion pBox, XYZ normal)
    {
      // 주어진 요소의 형상객체를 가져와서 geomElem변수에 저장
      Options op = new Options();
      op.ComputeReferences = true;
      GeometryElement geomElem = pBox.get_Geometry(op);

       // 반복구문을 이용하여 주어진 기준점과 일치하는 면을 찾기
      foreach (GeometryObject geomObj in geomElem)
      {
        if (geomObj is Solid)  // geomObj의 객체가 solid이면 아래의 구문 실행
        {
          Solid pSolid = geomObj as Solid;
          FaceArray faces = pSolid.Faces;
          foreach (Face pFace in faces)
          {
            PlanarFace pPlanarFace = (PlanarFace)pFace;

            // 반복구문을 이용하여 선택된 면이 기준점과 일치하는 체크
            if ((pPlanarFace != null) && pPlanarFace.Normal.IsAlmostEqualTo(normal))
            {
               // 면을 찾았으면 면을 응답
              return pPlanarFace;
            }
          }
        }

        // 필요에 따라서 나중에 사용이 될수 있는 구문 - 참조용
        //else if (geomObj is Instance)
        //{
        //}
        //else if (geomObj is Curve)
        //{
        //}
        //else if (geomObj is Mesh)
        //{
        //}
      }

      // 찾지못하였으면 null을 응답
      return null;
    }

    // 메소드 구문: 도움함수: 해당되는 타입의 뷰이름과 일치하는 요소를 찾기
    Element findElement(Type targetType, string targetName)
    {
      // 주어진 타입의 컬랙션을 가져와서 collector변수에 저장
      FilteredElementCollector collector = new FilteredElementCollector(RvDoc);
      collector.WherePasses(new ElementClassFilter(targetType));

      // collector에서 주어진 이름과 동일한 요소를 가져와서 elems면수에 저장 - LINQ 쿼리를 사용
      var targetElems = from element in collector where element.Name.Equals(targetName) select element;
      List elems = targetElems.ToList();

      // 주어진 이름으로 한개가 있으면 요소를 응답 
      if (elems.Count > 0)
      {  
        return elems[0];
      }

      // 요소 찾지 못하였으면 null을 응답
      return null;
    }

    // 메소드 구문: 도움함수: mm단위로 입력된 값을 피트단위로 변경
    double mmToFeet(double mmVal)
    {
      return mmVal / 304.8;
    }

  }
}