hi friends
I want to get the point reference on the wall that intersects the detail line.
Please see the attachment that shows what i want to get.
Thanks in advance..
How to get intersection point on wall
Hi.
Use the ReferenceIntersector class:
http://www.revitapidocs.com/2017/36f82b40-1065-2305-e260-18fc618e756f.htm
Here is a full explanation of using it:
Here is a full-fledged example:
It uses the ReferenceIntersector class to determine a point on a neighbouring, parallel wall to create dimensioning.
At that time, the method was called FindReferencesByDirection. It was later wrapped in the ReferenceIntersector class. The external command CmdDimensionWallsFindRefs demonstrating its use has been updated to use the new class and is available in The Building Coder samples on GitHub:
https://github.com/jeremytammik/the_building_coder_samples
Cheers,
Jeremy
You say: 'ReferenceIntersector is good but it doesn't find angled walls.. all walls with this method have to be parallel.'
That statement is incorrect.
Normally, it returns all the faces traversed by the ray. Going through the middle of the wall, that would normally be two, the front and the back, both.
Adding onto my previous post, I've tried some more things:
I've tried changing FindReferenceTarget.Edge to FindReferenceTarget.Face but I get a "One or more dimension references are or have become invalid." error, which I can't understand. Setting it to FindReferenceTarget.Element does produce dimensions, on the center-line of the walls.
The thing is, if I display the type of reference element found in the following loop, it displays 6 references (all of which are , matching what you said about 2 faces of each wall. But the dimension itself is only drawn on the "first" face being hit by the ray direction:
wallFilter = ElementClassFilter(Wall)
refIntersector = ReferenceIntersector(wallFilter, FindReferenceTarget.Edge, view3D)
referenceWithContext = refIntersector.Find( origin, vec )
refArray = ReferenceArray()
for ref in referenceWithContext:
wall = doc.GetElement(ref.GetReference())
print(type(wall))
print(type(ref))
refArray.Append(ref.GetReference())
The output is:
<type 'Wall'>
<type 'ReferenceWithContext'>
<type 'Wall'>
<type 'ReferenceWithContext'>
<type 'Wall'>
<type 'ReferenceWithContext'>
I'm also attaching an image showing the resulted dimension, where the ray intersects left to right and only hits the "first" edge of each wall.
Thank you
Well, an edge is 1-dimensional, and thuds infinitely thin, so your chance of hitting it with a ray is infinitely small.
If you wish to raise your chance to something that differs significantly from zero, a face is a better bet than an edge.
Furthermore, you ned to take imprecision into account.
When trying to intersect two curves, or, in this case, a ray and an edge. you never know what you will get unless you add some fuzziness to your calculations:
Yes, I definitely think requesting the element itself instead of a face or an edge from the ray tracer is the best place to start.
Regarding the faces found, you can always compare the results of your programmatic add-in solution with the required and desired results that you achieve manually through the user interface. Determine the differences, eliminate them, and Bob's your uncle:
You can use the ray tracer to determine the elements that you wish to dimension, then request their geometry with ComputeReferences == true and pick any faces you like to create the dimensioning. Look at the two different approaches dimensioning parallel walls:
https://thebuildingcoder.typepad.com/blog/about-the-author.html#5.45
One of them uses references retrieved via the Geometry property, the other uses the ones produced by the ray tracer.
The way these wall have been dimensioned isn't telling anyone how to set them out, it perhaps strikes through centre line of first wall but not others. If I were unfortunate enough to have to set out such a wall arrangement from an architect it would be done similar to below, this represents the minimum amount of geometric information needed to convey the location of the walls to site (excluding levels). We would obviously be using common grids to dimension from where possible.
Alternatively you could use spot coordinates for each wall end, angles and wall lengths from one end but not an inherently random point between the extents of a wall. Why a detail line and not a grid?
In the UI all these references would be from from solid geometry or grids i.e. things permanently visible in the view. If you hide/remove your detail line/grid then so goes all your dimensioning with it. This is why you will struggle with this in the API because the way you are dimensioning would not be usual in the UI (creating references to dimension things rather than using inherent ones). You would have to tab to the intersection between detail line and wall face and then what would that point on the wall tell you?
Not sure if the discussion has evolved beyond this but the drive for these requests is usually to automatically dimension things. I think there is an art to dimensioning things a balance between eliminating errors from running dimensions and compacting the space taken up by absolute ones. Deciding which side of an element to drag the dimension text. Moving text clear of lines and into empty spaces. A long way to go before eliminating the human. Probably in the BIM world we should just list the setting out points in a table and mark them up with reference point keys on the plan. Easier to compare the changes in two lists of points in excel than overlaying dimensions on a plan that could be done in numerous different ways.
I am a fan of DIY.
Calculating the intersection between a straight line and a plane is not difficult:
- https://en.wikipedia.org/wiki/Line%E2%80%93plane_intersection
- https://www.geomalgorithms.com/a05-_intersect-1.html
- https://stackoverflow.com/questions/34892197/how-calc-intersection-plane-and-line-unity3d
