anchor.diff:                  intersections (fun r (t : SimplePickTree) -> t.FindInternal(r, radiusD, radiusK)) bvh.Data ray root
               | None ->
                   let hits = 
  -                    _positions |> Array.choose ( fun p -> 
  -                        let p = _dataTrafo.Forward.TransformPos (V3d p)
  +                    x.positions |> Array.choose ( fun p -> 
  +                        let p = x.dataTrafo.Forward.TransformPos (V3d p)
                           let o = p - ray.Ray.Ray.Origin
                           let t = Vec.dot o ray.Ray.Ray.Direction
                           if t >= ray.TMin && t <= ray.TMax then
                               let dist = Vec.cross o ray.Ray.Ray.Direction |> Vec.lengthSquared
                               let r = radiusD + t * radiusK
                               if dist < r*r then
  -                                Some (RayHit(t, p))
  +                                Some (RayHit(t, { DataPosition = p; WorldPosition = x.dataTrafo.Backward.TransformPos p }))
                               else
                                   None
                           else
  
positive.code:         else
              Seq.empty
  
      member x.FindPoints(ray : Cone3d, tMin : float, tMax : float) =
          let len = ray.Direction.Length
          let tMin = tMin * len
          let tMax = tMax * len
          let radiusT1 = tan ray.Angle / len
          let rp = RayPart(FastRay3d(Ray3d(ray.Origin, ray.Direction / len)),tMin,tMax)
          let t = _trafo.GetValue()
          let rp = transform t.Inverse rp
          x.FindInternal(rp, 0.0, radiusT1) |> Seq.map (fun hit -> RayHit(hit.T, V3d hit.Value |> t.Forward.TransformPos))
          
      member x.FindPoints(cylinder : Cylinder3d) =
          let dir = cylinder.P1 - cylinder.P0
          let len = dir.Length
          let rp = RayPart(FastRay3d(Ray3d(cylinder.P0, dir / len)),0.0,len)
          let t = _trafo.GetValue()
          let rp = transform t.Inverse rp
          x.FindInternal(rp,cylinder.Radius, 0.0) |> Seq.map (fun hit -> RayHit(hit.T, V3d hit.Value |> t.Forward.TransformPos))
  
      member x.FindPoints(ray : Ray3d,  tMin : float, tMax : float, radius : float) =
          let len = ray.Direction.Length
          let tMin = tMin * len
          let tMax = tMax * len
          let rp = RayPart(FastRay3d(Ray3d(ray.Origin, ray.Direction / len)),tMin,tMax)
          let t = _trafo.GetValue()
          let rp = rp //transform t.Inverse rp
          x.FindInternal(rp, radius, 0.0) |> Seq.map (fun hit -> RayHit(hit.T, V3d hit.Value |> t.Forward.TransformPos))
  
negative.code:         let ray = part.Ray.Ray
          let np = trafo.Forward.TransformPos ray.Origin
          let nd = trafo.Forward.TransformDir ray.Direction
          let l = Vec.length nd
          let nr = FastRay3d(Ray3d(np,nd / l))
  
          let f = 1.0 / part.Ray.Ray.Direction.Length
          let ntmi = part.TMin * f
          let ntma = part.TMax * f
  
  