public static void GetSolidsOfwall(FamilyInstance familyInstance, ref List <Solid> solids)
{
Options options = new Options();
options.ComputeReferences = true;
options.IncludeNonVisibleObjects = true;
options.DetailLevel = ViewDetailLevel.Undefined;
string name = familyInstance.Name;
GeometryElement geometryElement = familyInstance.get_Geometry(options);
bool flag = geometryElement == null;
foreach (GeometryObject geometryObject in geometryElement)
{
GeometryInstance geometryInstance = geometryObject as GeometryInstance;
bool flag2 = null != geometryInstance;
if (flag2)
{
GeometryElement symbolGeometry = geometryInstance.GetSymbolGeometry();
foreach (GeometryObject geometryObject2 in symbolGeometry)
{
Solid solid = geometryObject2 as Solid;
bool flag3 = null == solid || solid.Faces.Size == 0 || solid.Edges.Size == 0;
if (!flag3)
{
solids.Add(solid);
}
}
}
}
}
private static GeometryInstance GetTheGeometryInstance(GeometryElement geomElem)
{
GeometryInstance geometryInstance = null;
foreach (GeometryObject geomObj in geomElem)
{
GeometryInstance geomInst = geomObj as GeometryInstance;
if (geomInst != null)
{
if (geometryInstance == null)
{
geometryInstance = geomInst;
continue;
}
else
{
return(null);
}
}
Solid solid = geomObj as Solid;
if (solid != null)
{
double?volume = GeometryUtil.GetSafeVolume(solid);
if (volume.HasValue || MathUtil.IsAlmostZero(volume.Value))
{
continue;
}
}
return(null);
}
return(geometryInstance);
}
/// <summary>
/// Проверить, содержит ли данный элемент объемную 3D-геометрию
/// </summary>
public static bool ContainsSolids(GeometryElement geoElem)
{
if (geoElem == null)
{
return(false);
}
foreach (GeometryObject geoObj in geoElem)
{
if (geoObj is Solid)
{
return(true);
}
if (geoObj is GeometryInstance)
{
GeometryInstance geomIns = geoObj as GeometryInstance;
GeometryElement instGeoElement = geomIns.GetInstanceGeometry();
bool check = ContainsSolids(instGeoElement);
if (check)
{
return(true);
}
}
}
return(false);
}
public List <PlanarFace> GetFacefamily(Document doc, FamilyInstance familyInstance)
{
List <PlanarFace> face = new List <PlanarFace>();
Options option = new Options();
option.ComputeReferences = true;
option.IncludeNonVisibleObjects = true;
option.DetailLevel = ViewDetailLevel.Undefined;
if (familyInstance != null)
{
GeometryElement geoElement = familyInstance.get_Geometry(option);
foreach (GeometryObject geoObject in geoElement)
{
GeometryInstance instance = geoObject as GeometryInstance;
if (instance != null)
{
FamilySymbol familySymbol = instance.Symbol as FamilySymbol;
GeometryElement instancegeotryElement = familySymbol.get_Geometry(option);
foreach (GeometryObject insto in instancegeotryElement)
{
Solid solid = insto as Solid;
if (solid != null)
{
foreach (PlanarFace geoFace in solid.Faces)
{
face.Add(geoFace);
}
}
}
}
}
}
return(face);
}
/// <summary>
/// Recursively retrieve all curves and solids
/// from the given geometry
/// </summary>
static void AddCurvesAndSolids(
GeometryElement geoElem,
List <Curve> curves,
List <Solid> solids)
{
foreach (GeometryObject obj in geoElem)
{
Curve curve = obj as Curve;
if (null != curve)
{
curves.Add(curve);
continue;
}
Solid solid = obj as Solid;
if (null != solid)
{
solids.Add(solid);
continue;
}
GeometryInstance inst = obj as GeometryInstance;
if (null != inst)
{
GeometryElement txGeoElem
= inst.GetInstanceGeometry(
inst.Transform);
AddCurvesAndSolids(txGeoElem,
curves, solids);
continue;
}
Debug.Assert(false,
"expected curve, solid or instance");
}
}
/// <summary>
/// Obtains the facing direction of the window.
/// </summary>
/// <param name="wall">The window.</param>
/// <returns>A normalized XYZ direction vector.</returns>
protected XYZ GetWindowDirection(FamilyInstance window)
{
Options options = new Options();
// Extract the geometry of the window.
GeometryElement geomElem = window.get_Geometry(options);
foreach (GeometryObject geomObj in geomElem.Objects)
{
// We expect there to be one main Instance in each window. Ignore the rest of the geometry.
GeometryInstance instance = geomObj as GeometryInstance;
if (instance != null)
{
// Obtain the Instance's transform and the nominal facing direction (Y-direction).
Transform t = instance.Transform;
XYZ facingDirection = t.BasisY;
// If the window is flipped in one direction, but not the other, the transform is left handed.
// The Y direction needs to be reversed to obtain the facing direction.
if ((window.FacingFlipped && !window.HandFlipped) || (!window.FacingFlipped && window.HandFlipped))
{
facingDirection = -facingDirection;
}
// Because the need to perform this operation on instances is so common,
// the Revit API exposes this calculation directly as the FacingOrientation property
// as shown in GetWindowDirectionAlternate()
return(facingDirection);
}
}
return(XYZ.BasisZ);
}
public static IList <Edge> AllEdgesBySymbol(this FamilyInstance familyInstance)
{
Options options = new Options();
options.ComputeReferences = true;
string name = familyInstance.Name;
IList <Edge> edgeList = new List <Edge>();
foreach (GeometryObject geometryObject1 in familyInstance.get_Geometry(options))
{
GeometryInstance geometryInstance = geometryObject1 as GeometryInstance;
if (null != geometryInstance)
{
foreach (GeometryObject geometryObject2 in geometryInstance.GetSymbolGeometry())
{
Solid solid = geometryObject2 as Solid;
if (!(null == solid) && solid.Faces.Size != 0 && solid.Edges.Size != 0)
{
foreach (Edge edge in solid.Edges)
{
if (edge != null)
{
edgeList.Add(edge);
}
}
}
}
}
}
return(edgeList);
}
static Solid GetUppermostSolid(Element elem)
{
Options opts = new Options {
IncludeNonVisibleObjects = true
};
foreach (GeometryObject gObjL1 in elem.get_Geometry(new Options()))
{
if (gObjL1 is GeometryInstance)
{
GeometryInstance instance =
gObjL1 as GeometryInstance;
foreach (GeometryObject gObjL2 in
instance.GetInstanceGeometry(instance.Transform))
{
if (gObjL2 is Solid)
{
return((Solid)gObjL2);
}
}
}
else if (gObjL1 is Solid)
{
return((Solid)gObjL1);
}
}
return(null);
}
private List <Solid> GetSolid()
{
Options option = GetGeometryOption();
GeometryElement geometryElement = element.get_Geometry(option);
List <Solid> solidList = new List <Solid>();
GeometryInstance geomInstance = null;
foreach (GeometryObject geoObj in geometryElement)
{
geomInstance = geoObj as GeometryInstance;
if (null == geomInstance)
{
continue;
}
foreach (GeometryObject geom in geomInstance.SymbolGeometry)
{
Solid solid = geom as Solid;
if (null == solid || 0 == solid.Faces.Size || 0 == solid.Edges.Size)
{
continue;
}
solidList.Add(solid);
}
}
return(solidList);
}
public static Polygon GetPolygonFromFaceFamilyInstance(FamilyInstance fi)
{
GeometryElement geoElem = fi.get_Geometry(new Options {
ComputeReferences = true
});
List <Curve> cs = new List <Curve>();
foreach (GeometryObject geoObj in geoElem)
{
GeometryInstance geoIns = geoObj as GeometryInstance;
if (geoIns == null)
{
continue;
}
Transform tf = geoIns.Transform;
foreach (GeometryObject geoSymObj in geoIns.GetSymbolGeometry())
{
Curve c = geoSymObj as Line;
if (c != null)
{
cs.Add(GeomUtil.TransformCurve(c, tf));
}
}
}
if (cs.Count < 3)
{
throw new Exception("Incorrect input curve!");
}
return(new Polygon(cs));
}
public static bool HasSolid(GeometryElement ge)
{
if (null == ge)
{
return(false);
}
foreach (var go in ge)
{
if (go is Solid)
{
Solid sd = go as Solid;
if (null != sd.Faces && sd.Faces.Size >= 1 || sd.Volume >= 0.0f)
{
return(true);
}
}
else if (go is GeometryInstance)
{
GeometryInstance geSub = go as GeometryInstance;
if (HasSolid(geSub.GetInstanceGeometry()))
{
return(true);
}
}
}
return(false);
}
private List <Solid> GetSolid(GeometryElement gelem)
{
List <Solid> solids = new List <Solid>();
foreach (GeometryObject o in gelem)
{
if (o is Solid)
{
solids.Add(o as Solid);
}
if (o is GeometryElement)
{
solids.AddRange(GetSolid(o as GeometryElement));
}
if (o is GeometryInstance)
{
GeometryInstance geometryInstance = o as GeometryInstance;
GeometryElement geometry = geometryInstance.GetInstanceGeometry();
solids.AddRange(GetSolid(geometry));
}
}
return(solids);
}
public static List <Solid> GetSolidsFromElement(GeometryElement geoElem)
{
Debug.WriteLine("Get solids from geoelem");
List <Solid> solids = new List <Solid>();
foreach (GeometryObject geoObj in geoElem)
{
if (geoObj is Solid)
{
Solid solid = geoObj as Solid;
if (solid == null)
{
continue;
}
if (solid.Volume == 0)
{
continue;
}
solids.Add(solid);
continue;
}
if (geoObj is GeometryInstance)
{
GeometryInstance geomIns = geoObj as GeometryInstance;
GeometryElement instGeoElement = geomIns.GetInstanceGeometry();
List <Solid> solids2 = GetSolidsFromElement(instGeoElement);
solids.AddRange(solids2);
}
}
Debug.WriteLine("Solids found: " + solids.Count.ToString());
return(solids);
}
private List <Solid> getSolidsListOfElement(ExternalCommandData revit, Element baseEl)
{
UIDocument uiDoc = revit.Application.ActiveUIDocument;
Document doc = uiDoc.Document;
GeometryElement geometryElement = baseEl.get_Geometry(new Options()
{
IncludeNonVisibleObjects = true, ComputeReferences = true, View = doc.ActiveView
});
List <Solid> geometrySolidsList = new List <Solid>();
foreach (GeometryObject geometryObject in geometryElement)
{
GeometryInstance geoInst = (geometryObject as GeometryInstance);
foreach (GeometryObject instObj in geoInst.SymbolGeometry)
{
Solid solid = instObj as Solid;
geometrySolidsList.Add(solid);
}
}
return(geometrySolidsList);
}
/// <summary>
/// Get Solids from Element
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
private static IList <Autodesk.Revit.DB.Solid> GetSolidsFromElement(Autodesk.Revit.DB.Element element)
{
GeometryElement geo = element.get_Geometry(new Options()
{
ComputeReferences = true
});
List <Autodesk.Revit.DB.Solid> solids = new List <Autodesk.Revit.DB.Solid>();
foreach (object obj in geo)
{
GeometryInstance geoinstance = obj as GeometryInstance;
if (geoinstance != null)
{
foreach (object solidobj in geoinstance.GetInstanceGeometry())
{
if (solidobj.GetType() == typeof(Autodesk.Revit.DB.Solid))
{
Autodesk.Revit.DB.Solid solid = solidobj as Autodesk.Revit.DB.Solid;
solids.Add(solid);
}
}
}
}
return(solids);
}
public static List <Solid> GetSolidsFromElement(GeometryElement geoElem)
{
List <Solid> solids = new List <Solid>();
foreach (GeometryObject geoObj in geoElem)
{
if (geoObj is Solid)
{
Solid solid = geoObj as Solid;
if (solid == null)
{
continue;
}
if (solid.Volume == 0)
{
continue;
}
solids.Add(solid);
continue;
}
if (geoObj is GeometryInstance)
{
GeometryInstance geomIns = geoObj as GeometryInstance;
GeometryElement instGeoElement = geomIns.GetInstanceGeometry();
List <Solid> solids2 = GetSolidsFromElement(instGeoElement);
solids.AddRange(solids2);
}
}
return(solids);
}
public static Curve GetCurveminfamily(FamilyInstance familyInstance)
{
IList <Curve> alllines = new List <Curve>();
Curve curvesmin = null;
Options option = new Options();
option.ComputeReferences = true;
option.IncludeNonVisibleObjects = false;
if (familyInstance != null)
{
GeometryElement geoElement = familyInstance.get_Geometry(option);
foreach (GeometryObject geoObject in geoElement)
{
GeometryInstance instance = geoObject as GeometryInstance;
if (null != instance)
{
GeometryElement instanceGeometryElement = instance.GetSymbolGeometry();
foreach (GeometryObject o in instanceGeometryElement)
{
Line curve = o as Line;
if (curve != null)
{
alllines.Add(curve);
}
}
var membercurvmax = alllines.OrderByDescending(x => x.Length).LastOrDefault();
curvesmin = membercurvmax;
}
}
}
return(curvesmin);
}
private void TraverseGeometryInstance(GeometryInstance geomInst)
{
GeometryElement instGeomElem = geomInst.GetSymbolGeometry();
foreach (GeometryObject instGeomObj in instGeomElem)
{
if (instGeomObj is Solid)
{
WriteSolid((Solid)instGeomObj);
}
else if (instGeomObj is Curve)
{
Curve curve = (Curve)instGeomObj;
Transaction createCurve = new Transaction(m_doc, "Create curve");
createCurve.Start();
m_doc.Create.NewDetailCurve(m_targetView, curve);
createCurve.Commit();
if (curve.Reference != null)
{
m_writer.WriteLine("Geometry curve - " + curve.Reference.ConvertToStableRepresentation(m_doc));
m_referencePlaneReferences.Add(curve);
}
else
{
m_writer.WriteLine("Geometry curve - but reference is null");
}
}
else
{
m_writer.WriteLine("Something else - " + instGeomObj.GetType().Name);
}
}
}
/// <summary>
/// Retrieve all faces from the first solid
/// encountered in the given geometry element.
/// </summary>
/// <param name="geoElement">geometry element</param>
/// <returns>faces</returns>
public FaceArray GetFacesFrom(GeometryElement geoElement)
{
//GeometryObjectArray geoElems = geoElement.Objects;
foreach (object o in geoElement)
{
Solid geoSolid = o as Solid;
if (null == geoSolid)
{
GeometryInstance instance = o as GeometryInstance;
if (null == instance)
{
continue;
}
GeometryElement geoElement2 = instance.SymbolGeometry;
_matrix = instance.Transform;
if (0 == geoElement2.Count <GeometryObject>())
{
continue;
}
return(GetFacesFrom(geoElement2));
}
FaceArray faces = geoSolid.Faces;
if (faces == null)
{
continue;
}
if (faces.Size == 0)
{
continue;
}
return(geoSolid.Faces);
}
return(null);
}
private Value AddCurves(FamilyInstance fi, GeometryElement geomElem, int count, ref CurveArray curves)
{
foreach (GeometryObject geomObj in geomElem)
{
Curve curve = geomObj as Curve;
if (null != curve)
{
curves.Append(curve);
continue;
}
//If this GeometryObject is Instance, call AddCurve
GeometryInstance geomInst = geomObj as GeometryInstance;
if (null != geomInst)
{
//curve live in family symbol in this case, need to apply the correct transform to get them in to
//the project coordinate system lining up with the instance
// http://wikihelp.autodesk.com/Revit/enu/2012/Help/API_Dev_Guide/0074-Revit_Ge74/0108-Geometry108/0110-Geometry110/GeometryInstances
//Autodesk.Revit.DB.GeometryElement transformedGeomElem // curves transformed into project coords
// = geomInst.GetInstanceGeometry(geomInst.Transform);
//AddCurves(fi, transformedGeomElem, count, ref curves);
GeometryElement transformedGeomElem // curves transformed into project coords
= geomInst.GetInstanceGeometry(geomInst.Transform.Inverse);
AddCurves(fi, transformedGeomElem, count, ref curves);
//Autodesk.Revit.DB.GeometryElement symbolTransformedGeomElem // curves in symbol coords
// = geomInst.GetSymbolGeometry(geomInst.Transform);
//AddCurves(fi, symbolTransformedGeomElem, count, ref curves);
}
}
return(Value.NewContainer(curves));
}
/// <summary>
/// Extract a 3D solid from a Revit GeometryObject
/// </summary>
/// <param name="geoObject"></param>
/// <param name="_outSolid"></param>
/// <returns></returns>
public static bool TryeGetGeometryDataFromGeometryObject(GeometryObject geoObject, out Solid _outSolid, out DynamoSolid _outDynSolid)
{
DynamoSolid outdynSolid = null;
Solid outSolid = null;
bool success;
// Check if its is a Geometry Instance
if (geoObject is GeometryInstance)
{
GeometryInstance geoInstance = geoObject as GeometryInstance;
foreach (Solid solid in geoInstance.GetInstanceGeometry())
{
// Skip to next element in iteration if any of the following conditions are met
if (null == solid || 0 == solid.Faces.Size || 0 == solid.Edges.Size)
{
continue;
}
DynamoSolid dynSolidGeo = ToDynamoSolid(solid);
// Sometimes a geometry element can be a null solid
if (dynSolidGeo != null)
{
outdynSolid = dynSolidGeo;
outSolid = solid;
}
}
}
// Check if it is Solid
else if (geoObject is Solid)
{
Solid solid = geoObject as Solid;
DynamoSolid dynSolidGeo = ToDynamoSolid(solid);
// Sometimes a geometry element can be a null solid
if (dynSolidGeo != null)
{
outdynSolid = dynSolidGeo;
outSolid = solid;
}
}
if (outdynSolid == null && outSolid == null)
{
success = false;
}
else
{
success = true;
}
_outDynSolid = outdynSolid;
_outSolid = outSolid;
return(success);
}
public EdgeArray FlEdgeArray(FamilyInstance familyInstance)
{
EdgeArray edge = new EdgeArray();
Options option = new Options();
option.ComputeReferences = true;
option.IncludeNonVisibleObjects = true;
option.DetailLevel = ViewDetailLevel.Undefined;
if (familyInstance != null)
{
GeometryElement geoElement = familyInstance.get_Geometry(option);
foreach (GeometryObject geoObject in geoElement)
{
GeometryInstance instance = geoObject as GeometryInstance;
if (instance != null)
{
FamilySymbol familySymbol = instance.Symbol as FamilySymbol;
GeometryElement instancegeotryElement = familySymbol.get_Geometry(option);
foreach (GeometryObject insto in instancegeotryElement)
{
Solid solid = insto as Solid;
if (solid != null)
{
foreach (var geoFace in solid.Edges)
{
edge.Append(geoFace as Edge);
}
}
}
}
}
}
return(edge);
}
public void GetSolidsFromSymbol(FamilyInstance familyInstance, ref List <Solid> solids)
{
Options option = new Options();
option.ComputeReferences = true;
option.IncludeNonVisibleObjects = true;
option.DetailLevel = ViewDetailLevel.Undefined;
if (familyInstance != null)
{
GeometryElement geoElement = familyInstance.get_Geometry(option);
foreach (GeometryObject geoObject in geoElement)
{
GeometryInstance instance = geoObject as Autodesk.Revit.DB.GeometryInstance;
if (null != instance)
{
Transform transform = familyInstance.GetTransform();
GeometryElement instanTVDCEGeometryElement = instance.GetSymbolGeometry(transform);
foreach (GeometryObject instObj in instanTVDCEGeometryElement)
{
// Try to find solid
Solid solid = instObj as Solid;
if (null == solid || 0 == solid.Faces.Size || 0 == solid.Edges.Size)
{
continue;
}
if (!solids.Contains(solid))
{
solids.Add(solid);
}
}
}
}
}
}
public static List <Solid> GetSolid(Element element, Options option)
{
Contract.Requires(null != element && null != option);
GeometryElement geometryElement = element.get_Geometry(option);
List <Solid> solidList = new List <Solid>();
GeometryInstance geomInstance = null;
foreach (GeometryObject geoObj in geometryElement)
{
geomInstance = geoObj as GeometryInstance;
if (null == geomInstance)
{
continue;
}
foreach (GeometryObject geom in geomInstance.SymbolGeometry)
{
Solid solid = geom as Solid;
if (null == solid || 0 == solid.Faces.Size || 0 == solid.Edges.Size)
{
continue;
}
solidList.Add(solid);
}
}
return(solidList);
}
/// <summary>
/// Return a list of all materials by recursively traversing
/// all the object's solids' faces, retrieving their face
/// materials, and collecting them in a list.
///
/// Original implementation, not always robust as noted by Andras Kiss in
/// http://thebuildingcoder.typepad.com/blog/2008/10/family-instance-materials.html?cid=6a00e553e1689788330115713e2e3c970b#comment-6a00e553e1689788330115713e2e3c970b
/// </summary>
public List <string> GetMaterials1(
Document doc,
GeometryElement geo)
{
List <string> materials = new List <string>();
//foreach( GeometryObject o in geo.Objects ) // 2012
foreach (GeometryObject o in geo) // 2013
{
if (o is Solid)
{
Solid solid = o as Solid;
foreach (Face face in solid.Faces)
{
//string s = face.MaterialElement.Name; // 2011
string s = FaceMaterialName(doc, face); // 2012
materials.Add(s);
}
}
else if (o is GeometryInstance)
{
GeometryInstance i = o as GeometryInstance;
materials.AddRange(GetMaterials1(
doc, i.SymbolGeometry));
}
}
return(materials);
}
private Solid GetSolid(Element element)
{
Solid solid = null;
Options option = new Options();
option.ComputeReferences = true;
option.DetailLevel = ViewDetailLevel.Fine;
GeometryElement geo = null;
geo = element.get_Geometry(option); //需要获取Symbol才能获取Geometry。或许是因为常规模型的原因。待解决
foreach (GeometryObject g in geo)
{
if (g is Solid)
{
solid = g as Solid;
break;
}
else if (g is GeometryInstance)
{
GeometryInstance geometryInstance = g as GeometryInstance;
GeometryElement geometryElement = geometryInstance.GetInstanceGeometry();
foreach (GeometryObject gt in geometryElement)
{
solid = gt as Solid;
break;
}
}
}
return(solid);
}
private IList <Mesh> getMeshes(GeometryElement ge)
{
IList <Mesh> rv = new List <Mesh>();
if (ge != null)
{
foreach (GeometryObject g in ge)
{
GeometryInstance i = g as GeometryInstance;
if (i != null)
{
GeometryElement ge2 = i.GetInstanceGeometry();
if (ge2 != null)
{
rv = rv.Concat(getMeshes(ge2)).ToList();
}
}
else
{
Mesh mesh = g as Mesh;
if (mesh != null && mesh.Vertices.Count > 0)
{
rv.Add(mesh);
}
}
}
}
return(rv);
}
/// <summary>
///
/// </summary>
/// <param name="geoElement"></param>
/// <param name="outPutSolids"></param>
private static void ProcessStairs(GeometryElement geoElement, List <DynamoSolid> outPutSolids)
{
for (int j = 0; j < geoElement.Count(); j++)
{
GeometryInstance geoIns = geoElement.ElementAt(j) as GeometryInstance;
//GetInstanceGeometry returns the geometry represented in the coordinate system of the project where the instance is placed.
// https://thebuildingcoder.typepad.com/blog/2010/01/geometry-options.html
GeometryElement instanceGeo = geoIns.GetInstanceGeometry();
foreach (var item in instanceGeo)
{
if (item is Solid)
{
Solid solid = item as Solid;
// Skip item if does not contain solid geo
if (solid == null)
{
continue;
}
DynamoSolid solidGeo = GeometryExtraction.ToDynamoSolid(solid);
// Skip item if does not contain solid geo
if (solidGeo == null)
{
continue;
}
outPutSolids.Add(solidGeo);
}
}
}
}
//在族实例上定位连接点
private XYZ LocatePointOnFamilyInstance(FamilyInstance fi, Direction dir)
{
//找到工井族文件中左边界或右边界的几何体，利用id定位
Options opt = new Options();
opt.IncludeNonVisibleObjects = true;//很重要，由于view为null需要将不可见的对象变为可见，否则提取空集
GeometryElement ge = null;
switch (dir)
{
case (Direction.left):
ge = welldoc.GetElement(new ElementId(leftId)).get_Geometry(opt);
break;
case (Direction.right):
ge = welldoc.GetElement(new ElementId(rightId)).get_Geometry(opt);
break;
}
//提取集合体上的面元素
Solid solid = null;
foreach (GeometryObject obj in ge)
{
if (obj is Solid)
{
solid = obj as Solid;
break;
}
}
FaceArray fcArr = null;
if (solid != null)
{
fcArr = solid.Faces;
}
//找到边界的面，并将面原点的族坐标转换为模型坐标
Transform trans = null;
Options opt1 = new Options();
opt1.ComputeReferences = false;
opt1.View = doc.ActiveView;
GeometryElement geoElement = fi.get_Geometry(opt1);
foreach (GeometryObject obj in geoElement) //利用GeometryInstrance的Transform提取坐标转换矩阵
{
if (obj is GeometryInstance)
{
GeometryInstance inst = obj as GeometryInstance;
trans = inst.Transform;
break;
}
}
EdgeArray edArr = solid.Edges;
XYZ planeOrigin = (fcArr.get_Item(0) as PlanarFace).Origin;
return(trans.OfPoint(new XYZ(planeOrigin.X, planeOrigin.Y + edArr.get_Item(0).ApproximateLength / 2, planeOrigin.Z - edArr.get_Item(1).ApproximateLength / 2)));
}
public List <GeometryObject> GetLinkedDWGCurves(ImportInstance curLink, Document curDoc)
{
//returns list of curves for linked DWG file
List <GeometryObject> curveList = new List <GeometryObject>();
Options curOptions = new Options();
GeometryElement geoElement = null;
GeometryInstance geoInstance = null;
GeometryElement geoElem2 = null;
//get geometry from current link
geoElement = curLink.get_Geometry(curOptions);
foreach (GeometryObject geoObject in geoElement)
{
//convert geoObject to geometry instance
geoInstance = (GeometryInstance)geoObject;
geoElem2 = geoInstance.GetInstanceGeometry();
foreach (GeometryObject curObj in geoElem2)
{
//add object to list
curveList.Add(curObj);
}
}
//return list of geometry
return(curveList);
}
private void TraverseGeometryInstance( GeometryInstance geomInst )
{
GeometryElement instGeomElem = geomInst.GetSymbolGeometry();
foreach( GeometryObject instGeomObj in instGeomElem )
{
if( instGeomObj is Solid )
{
WriteSolid( (Solid) instGeomObj );
}
else if( instGeomObj is Curve )
{
Curve curve = (Curve) instGeomObj;
Transaction createCurve = new Transaction( m_doc, "Create curve" );
createCurve.Start();
m_doc.Create.NewDetailCurve( m_targetView, curve );
createCurve.Commit();
if( curve.Reference != null )
{
m_writer.WriteLine( "Geometry curve - " + curve.Reference.ConvertToStableRepresentation( m_doc ) );
m_referencePlaneReferences.Add( curve );
}
else
m_writer.WriteLine( "Geometry curve - but reference is null" );
}
else
{
m_writer.WriteLine( "Something else - " + instGeomObj.GetType().Name );
}
}
}
/// <summary>
/// Obtain a point collection outlining a GeometryObject
/// </summary>
/// <param name="geomInst"></param>
/// <param name="pts"></param>
protected static void GetPointCloud(GeometryInstance geomInst, List<XYZ> pts)
{
foreach (var gObj in geomInst.GetInstanceGeometry())
{
if (gObj is Autodesk.Revit.DB.Solid)
{
GetPointCloud(gObj as Autodesk.Revit.DB.Solid, pts);
}
else if (gObj is GeometryInstance)
{
GetPointCloud(gObj as GeometryInstance, pts);
}
}
}
private void SetDefaultMaterialProperties(GeometryInstance instance, Material mtrl, SceneMaterial material)
{
var brdf = (BrdfTypes)(int)material["brdf_id"];
if (brdf == BrdfTypes.BRDF_TYPE_GLOSSY_REFLECTION_MEASURED)
{
int th, td, pd;
string[] names =
{
"chrome-steel.binary", "gold-metallic-paint.binary", "green-acrylic.binary", "chrome-steel.binary",
"color-changing-paint1.binary", "colonial-maple-223.binary", "dark-blue-paint.binary",
"green-fabric.binary",
"green-plastic.binary", "hematite.binary", "nylon.binary", "pearl-paint.binary"
};
Random rnd = new Random();
string fileName = string.Format(@"F:\3D\Brdfs\merl\{0}", names[rnd.Next(0, names.Length - 1)]);
Trace.TraceInformation("Loading material data for " + fileName);
var data =
OptixMaterialFactory.FileHelper.Read(fileName, out th, out td, out pd)
.Select(i => (float)i)
.ToArray();
mtrl["nThetaH"].Set(th);
mtrl["nThetaD"].Set(td);
mtrl["nPhiD"].Set(pd);
var bDesc = new BufferDesc()
{
Width = (uint)data.Length,
Format = Format.Float,
Type = BufferType.Input
};
var viBuffer = new Buffer(Session.OptixContext, bDesc);
viBuffer.SetData(data);
mtrl["brdf"].Set(viBuffer);
}
else
{
var bDesc = new BufferDesc()
{
Width = (uint)1,
Format = Format.Float,
Type = BufferType.Input
};
var viBuffer = new Buffer(Session.OptixContext, bDesc);
viBuffer.SetData(new[] { 1u });
mtrl["brdf"].Set(viBuffer);
}
}
private void Stream(ArrayList data, GeometryInstance inst)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(GeometryInstance)));
data.Add(new Snoop.Data.Object("Symbol", inst.Symbol));
data.Add(new Snoop.Data.Object("Symbol geometry", inst.SymbolGeometry));
data.Add(new Snoop.Data.Object("Transform", inst.Transform));
}
public override void SetScene(IRayEngineScene secn)
{
string shaderPath = Path.GetFullPath(@"G:\Git\RayDen\RayDen.OptixEngine\Cuda\Scripts\CudaScripts\hitkernel.ptx");
Tracer.TraceLine("OptixIntersectionDevice - Initializing Optix");
this.scene = (RayEngineScene) secn;
var scn = scene.SceneGeometry;
Material material = new Material(Context);
material.Programs[0] = new SurfaceProgram(Context, RayHitType.Closest, shaderPath, "first_hit");
// material.Programs[1] = new SurfaceProgram(Context, RayHitType.Any, shaderPath, "shadow");
var mVertices = scn.Vertices.ToList();
var mNormals = scn.Normals.ToList();
List<UV> mTexcoords = null;
mTexcoords = scn.TexCoords == null ? new List<UV>() : scn.TexCoords.Select(it=>new UV(it.x,it.y)).ToList();
var vDesc = new BufferDesc() { Width = (uint)mVertices.Count, Format = Format.Float3, Type = BufferType.Input };
var nDesc = new BufferDesc() { Width = (uint)mNormals.Count, Format = Format.Float3, Type = BufferType.Input };
var tcDesc = new BufferDesc() { Width = (uint)mTexcoords.Count, Format = Format.Float2, Type = BufferType.Input };
// Create the buffers to hold our geometry data
var vBuffer = new DeviceBuffer(Context, vDesc);
var nBuffer = new DeviceBuffer(Context, nDesc);
var tcBuffer = new DeviceBuffer(Context, tcDesc);
vBuffer.SetData(mVertices.ToArray());
nBuffer.SetData(mNormals.ToArray());
tcBuffer.SetData(mTexcoords.ToArray());
foreach (var triangleMesh in scene.Meshes.Cast<TriangleMeshInfo>())
{
var group = triangleMesh;
var viDesc = new BufferDesc() { Width = (uint)(group.TrianglesCount), Format = Format.Int3, Type = BufferType.Input };
var niDesc = new BufferDesc() { Width = (uint)(group.TrianglesCount), Format = Format.Int3, Type = BufferType.Input };
var tiDesc = new BufferDesc() { Width = (uint)(group.TrianglesCount), Format = Format.Int3, Type = BufferType.Input };
var ofsDesc = new BufferDesc()
{
Width = (uint) (group.TrianglesCount),
Format = Format.UInt,
Type = BufferType.Input
};
var viBuffer = new DeviceBuffer(Context, viDesc);
var niBuffer = new DeviceBuffer(Context, niDesc);
var tiBuffer = new DeviceBuffer(Context, tiDesc);
var gIndexes =
scene.Triangles.ToList().GetRange(group.StartTriangle, group.TrianglesCount)
.SelectMany(tri => new []
{
tri.v0.VertexIndex,
tri.v1.VertexIndex,
tri.v2.VertexIndex
})
.ToArray();
var gNIndexes =
scene.Triangles.ToList().GetRange(group.StartTriangle, group.TrianglesCount)
.SelectMany(tri => new[]
{
tri.v0.NormalIndex,
tri.v1.NormalIndex,
tri.v2.NormalIndex
})
.ToArray();
var gTIndexes =
scene.Triangles.ToList().GetRange(group.StartTriangle, group.TrianglesCount)
.SelectMany(tri => new []
{
tri.v0.TexCoordIndex,
tri.v1.TexCoordIndex,
tri.v2.TexCoordIndex
})
.ToArray();
viBuffer.SetData(Convert(gIndexes).ToArray());
niBuffer.SetData(Convert(gNIndexes).ToArray());
tiBuffer.SetData(Convert(gTIndexes).ToArray());
var geometry = new Geometry(Context);
geometry.IntersectionProgram = new Program(Context, IntersecitonProgPath, IntersecitonProgName);
geometry.BoundingBoxProgram = new Program(Context, BoundingBoxProgPath, BoundingBoxProgName);
geometry.PrimitiveCount = (uint)(group.EndTriangle - group.StartTriangle);
geometry["vertex_buffer"].Set(vBuffer);
geometry["normal_buffer"].Set(nBuffer);
geometry["texcoord_buffer"].Set(tcBuffer);
geometry["vindex_buffer"].Set(viBuffer);
geometry["nindex_buffer"].Set(niBuffer);
geometry["tindex_buffer"].Set(tiBuffer);
geometry["mesh_offset"].SetInt4(group.StartTriangle);
//geometry[ "material_buffer" ].Set(mtBuffer);
//create a geometry instance
var instance = new GeometryInstance(Context);
instance.Geometry = geometry;
instance.AddMaterial(material);
//create an acceleration structure for the geometry
Acceleration accel = new Acceleration(Context, Builder, Traverser);
if (Builder == AccelBuilder.Sbvh || Builder == AccelBuilder.TriangleKdTree)
{
accel.VertexBufferName = "vertex_buffer";
accel.IndexBufferName = "vindex_buffer";
}
//now attach the instance and accel to the geometry group
GeoGroup.Acceleration = accel;
GeoGroup.AddChildren(new[] { instance });
}
Program rayGen = new Program(Context, shaderPath, "intersector_camera");
Program exception = new Program(Context, shaderPath, "exception");
Program miss = new Program(Context, shaderPath, "miss");
Context["intersect_ray_type"].Set(0u);
Context["scene_epsilon"].Set(0.0001f);
Context.SetRayGenerationProgram(0, rayGen);
Context.SetExceptionProgram(0, exception);
Context.SetRayMissProgram(0, miss);
Context["top_object"].Set(GeoGroup);
Tracer.TraceLine("OptixIntersectionDevice - Compiling Optix contex");
Context.Compile();
Context.BuildAccelTree();
Tracer.TraceLine("OptixIntersectionDevice - Complete");
}
public void ExpandLibraryNode( LibraryNode lnode, string referrerId, Matrix4 localTransform, Matrix4 transform, ColladaMeshInfo meshInfo )
{
// recurse through any child nodes
int childNo = 0;
foreach( LibraryNode child in lnode.children )
ExpandLibraryNode( child, referrerId + "." + (childNo++).ToString(), localTransform, transform, meshInfo );
// expand geometry_instance references
int instNo = 0;
foreach( string geoInstanceId in lnode.geoInstanceIds )
{
GeometryInstance geoInstance = new GeometryInstance( referrerId + "." + (instNo++).ToString(), null, localTransform, transform );
if( meshInfo.Geometries.ContainsKey( geoInstanceId ) )
{
// this was an instance_geometry instead of an instance_controller in 1.4 terms
geoInstance.controller = null;
geoInstance.geoSet = meshInfo.Geometries[ geoInstanceId ].Clone( geoInstance.name );
meshInfo.GeoInstances.Add( geoInstance );
}
}
}
private static GeometryInstance CreateGeometryInstance( string nodeName, string parentBone, ref Matrix4 localTransform, ref Matrix4 transform, XmlNode node, ColladaMeshInfo meshInfo )
{
GeometryInstance geoInstance = new GeometryInstance( nodeName, parentBone, localTransform, transform );
#if WORKS_AS_EXPECTED
XmlNode bindNode = node.SelectSingleNode( "bind_material" );
if( null != bindNode )
{
geoInstance.bindMaterial = new BindMaterial( bindNode, meshInfo.materialNamespace );
}
#else
foreach( XmlNode child in node.ChildNodes )
{
if( "bind_material" == child.Name )
{
geoInstance.bindMaterial = new BindMaterial( child, MaterialScriptBuilder.MaterialNamespace );
}
}
#endif
return geoInstance;
}
private void BuildGeometry(SceneMeshData SceneData, SceneMeshEntity[] sceneMesh, bool hasAreaLights = false, IEnumerable<SceneLightsource> areaLights = null)
{
topObject = new GeometryGroup(Session.OptixContext);
Session.OptixContext["scene_sphere_radius"].Set(SceneData.BoundingSphereRadius);
Session.OptixContext["scene_sphere_center"].SetFloat3(SceneData.BoundingSphereCenter);
var vDesc = new BufferDesc { Width = (uint)SceneData.Positions.Count, Format = Format.Float3, Type = BufferType.Input };
var nDesc = new BufferDesc { Width = (uint)SceneData.Normals.Count, Format = Format.Float3, Type = BufferType.Input };
var tcDesc = new BufferDesc { Width = (uint)SceneData.TexCoords.Count, Format = Format.Float2, Type = BufferType.Input };
var vBuffer = new Buffer(Session.OptixContext, vDesc);
var nBuffer = new Buffer(Session.OptixContext, nDesc);
var tcBuffer = new Buffer(Session.OptixContext, tcDesc);
vBuffer.SetData(SceneData.Positions.ToArray());
nBuffer.SetData(SceneData.Normals.ToArray());
tcBuffer.SetData(SceneData.TexCoords.ToArray());
var lightTriangleIndexes = new Dictionary<string, List<int>>(StringComparer.InvariantCultureIgnoreCase);
var instances = new List<GeometryInstance>();
var triLights = new List<TriangleLight>();
int idx = 0;
foreach (var group in sceneMesh)
{
//empty group
if (group.VertexIndexes.Count == 0 && group.NormalIndexes.Count == 0 && group.TextureIndexes.Count == 0)
continue;
var center = new Vector3();
foreach (var vi in group.VertexIndexes)
{
center += SceneData.Positions[vi.X];
center += SceneData.Positions[vi.Y];
center += SceneData.Positions[vi.Z];
center /= 3.0f;
}
//ValidateGroup( group );
//var mat = this.ResolveMaterial(group.Material);
bool normalsUseVIndices = GenerateNormals && group.NormalIndexes.Count == 0 && SceneData.Normals.Count > 0;
if (normalsUseVIndices)
Debug.Assert(SceneData.Normals.Count == SceneData.Positions.Count);
int numNormIndices = normalsUseVIndices ? group.VertexIndexes.Count : group.NormalIndexes.Count;
var viDesc = new BufferDesc() { Width = (uint)group.VertexIndexes.Count, Format = Format.Int3, Type = BufferType.Input };
var niDesc = new BufferDesc() { Width = (uint)numNormIndices, Format = Format.Int3, Type = BufferType.Input };
var tiDesc = new BufferDesc() { Width = (uint)group.TextureIndexes.Count, Format = Format.Int3, Type = BufferType.Input };
var viBuffer = new Buffer(Session.OptixContext, viDesc);
var niBuffer = new Buffer(Session.OptixContext, niDesc);
var tiBuffer = new Buffer(Session.OptixContext, tiDesc);
viBuffer.SetData(group.VertexIndexes.ToArray());
niBuffer.SetData(normalsUseVIndices ? group.VertexIndexes.ToArray() : group.NormalIndexes.ToArray());
tiBuffer.SetData(group.TextureIndexes.ToArray());
var geometry = new Geometry(Session.OptixContext);
string intersect_program = "mesh_intersect";
string isect_script = IntersectionScript;
//if (!string.IsNullOrWhiteSpace(group.mtrl) && matTypes.ContainsKey(group.mtrl))
//{
// if (matTypes[group.mtrl].Equals("Volume"))
// {
// intersect_program = "volume_mesh_intersect";
// isect_script = GetScript("triangle_mesh_iterative.ptx");
// }
//}
geometry.IntersectionProgram = new Program(Session.OptixContext, isect_script, intersect_program);
geometry.BoundingBoxProgram = new Program(Session.OptixContext, isect_script, "mesh_bounds");
geometry.PrimitiveCount = (uint)group.VertexIndexes.Count;
geometry["vertex_buffer"].Set(vBuffer);
geometry["normal_buffer"].Set(nBuffer);
geometry["texcoord_buffer"].Set(tcBuffer);
geometry["vindex_buffer"].Set(viBuffer);
geometry["nindex_buffer"].Set(niBuffer);
geometry["tindex_buffer"].Set(tiBuffer);
var instance = new GeometryInstance(Session.OptixContext);
instance.Geometry = geometry;
instance["geometric_center"].SetFloat3(center);
//instance.AddMaterial(mat);
group.EngineEntity = geometry;
if (group.Material != null)
{
int lindex;
if (hasAreaLights && MeshIsLight(group.Name, out lindex))
{
instance.AddMaterial(this.GetLightMaterial(group.Material, lindex));
}
else
{
var mtrl = ResolveMaterial(group.Material);
if (mtrl != null)
{
group.Material.EngineEntity = mtrl;
instance.AddMaterial(mtrl);
SetDefaultMaterialProperties(instance, mtrl, group.Material);
}
else
{
Tracer.WriteLine("Mesh {0} missed material {1}", group.Name, group.Material.Name);
}
}
}
else
{
Tracer.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ----Mesh {0} missed material {1}", group.Name, group.Material);
Console.ReadLine();
}
//if (!string.IsNullOrWhiteSpace(LightNameTemplate))
//{
// Regex lightReg = new Regex(LightNameTemplate, RegexOptions.IgnoreCase);
// if (lightReg.IsMatch(group.Name))
// {
// var lt = new Lightsource()
// {
// Type = LightSourceTypes.Area,
// Emission = Scene.LightGain,
// Name = group.Name,
// };
// lt[Lightsource.AreaMeshName] = group.Name;
// Scene.Lights = Scene.Lights.Union(new[] { lt }).ToArray();
// }
//}
if (hasAreaLights)
{
var light =
areaLights.FirstOrDefault(
lt => lt.Name.Equals(group.Name, StringComparison.InvariantCultureIgnoreCase));
// SetDefaultLightProperties(instance, light);
if (light != null)
{
var ti = new List<int>();
lightTriangleIndexes.Add(group.Name, ti);
for (int index = 0; index < group.VertexIndexes.Count; index++)
{
var vIndex = group.VertexIndexes[index];
var v1 = SceneData.Positions[vIndex.X];
var v2 = SceneData.Positions[vIndex.Y];
var v3 = SceneData.Positions[vIndex.Z];
var e1 = v2 - v3;
var e2 = v1 - v3;
Vector3 n = Vector3.Cross(ref e1, ref e2);//SceneGraph.LightOrientation *
if (group.NormalIndexes.Any())
{
n = (SceneData.Normals[group.NormalIndexes[index].X]);//Scene.LightOrientation *
}
n.Normalize();
ti.Add(idx + 1);
triLights.Add(new TriangleLight()
{
color = light.Color, //Emission * emissionScale,
v1 = v1,
v2 = v2,
v3 = v3,
normal = n,
idx = idx++
});
}
}
}
instances.Add(instance);
}
var Builder = AccelBuilder.Sbvh;
var Traverser = AccelTraverser.Bvh;
//create an acceleration structure for the geometry
var accel = new Acceleration(Session.OptixContext, Builder, Traverser);
if (Builder == AccelBuilder.Sbvh || Builder == AccelBuilder.TriangleKdTree)
{
accel.VertexBufferName = "vertex_buffer";
accel.IndexBufferName = "vindex_buffer";
}
//now attach the instance and accel to the geometry group
topObject.Acceleration = accel;
topObject.AddChildren(instances);
topObject.Acceleration.MarkAsDirty();
BuildCache.Add("LightTrianglesIndexes", lightTriangleIndexes);
BuildCache.Add("LightTriangles", triLights);
}
