The Building Coder: Is a Given Element Hidden in a View?

Lately, several people have asked about how to determine the visibility of an element relative to a given view crop box.

Here is a nice little stand-alone method IsElementHiddenInView that can be plugged in to any add-in to answer that question, plus a couple of others as well, shared by Frode Tørresdal of Norconsult Informasjonssystemer AS.

For any given element e and view v, it returns true if e is hidden in v.

This is determined by performing the following checks:

Does v have a crop box defined? Does e lies completely outside it? If not, is less that 25 % of the element bounding box contained within the view crop box?
Is e specifically hidden in the view, by element?
Is the category of e or one of its parent categories hidden in v?

Here is the code:

  /// <summary>
  /// Return true if the given element e is hidden
  /// in the view v. This might be due to:
  /// - e lies outside the view crop box
  /// - e is specifically hidden in the view, by element
  /// - the category of e or one of its parent 
  /// categories is hidden in v.
  /// </summary>
  bool IsElementHiddenInView(
    Element e,
    View v )
  {
    if( v.CropBoxActive )
    {
      BoundingBoxXYZ viewBox = v.CropBox;
      BoundingBoxXYZ elBox = e.get_BoundingBox( v );
 
      Transform transInv = v.CropBox.Transform.Inverse;
 
      elBox.Max = transInv.OfPoint( elBox.Max );
      elBox.Min = transInv.OfPoint( elBox.Min );
 
      // The transform above might switch 
      // max and min values.
 
      if( elBox.Min.X > elBox.Max.X )
      {
        XYZ tmpP = elBox.Min;
        elBox.Min = new XYZ( elBox.Max.X, elBox.Min.Y, 0 );
        elBox.Max = new XYZ( tmpP.X, elBox.Max.Y, 0 );
      }
 
      if( elBox.Min.Y > elBox.Max.Y )
      {
        XYZ tmpP = elBox.Min;
        elBox.Min = new XYZ( elBox.Min.X, elBox.Max.Y, 0 );
        elBox.Max = new XYZ( tmpP.X, elBox.Min.Y, 0 );
      }
 
      if( elBox.Min.X > viewBox.Max.X
        || elBox.Max.X < viewBox.Min.X
        || elBox.Min.Y > viewBox.Max.Y
        || elBox.Max.Y < viewBox.Min.Y )
      {
        return true;
      }
      else
      {
        BoundingBoxXYZ inside = new BoundingBoxXYZ();
 
        double x, y;
 
        x = elBox.Max.X;
 
        if( elBox.Max.X > viewBox.Max.X )
          x = viewBox.Max.X;
 
        y = elBox.Max.Y;
 
        if( elBox.Max.Y > viewBox.Max.Y )
          y = viewBox.Max.Y;
 
        inside.Max = new XYZ( x, y, 0 );
 
        x = elBox.Min.X;
 
        if( elBox.Min.X < viewBox.Min.X )
          x = viewBox.Min.X;
 
        y = elBox.Min.Y;
 
        if( elBox.Min.Y < viewBox.Min.Y )
          y = viewBox.Min.Y;
 
        inside.Min = new XYZ( x, y, 0 );
 
        double eBBArea = ( elBox.Max.X - elBox.Min.X )
          * ( elBox.Max.Y - elBox.Min.Y );
 
        double einsideArea =
          ( inside.Max.X - inside.Min.X )
          * ( inside.Max.Y - inside.Min.Y );
 
        double factor = einsideArea / eBBArea;
 
        if( factor < 0.25 )
          return true;
      }
    }
 
    bool hidden = e.IsHidden( v );
 
    if( !hidden )
    {
      Category cat = e.Category;
 
      while( null != cat && !hidden )
      {
        hidden = !cat.get_Visible( v );
        cat = cat.Parent;
      }
    }
    return hidden;
  }