/// <summary> /// Reads the points of the node /// </summary> /// <param name="buffer">The buffer to contains the points</param> /// <param name="quota">The quota of which the number of the points that the invocation of this function should provide</param> /// <returns>The number of points that are read</returns> public int ReadPoints(IntPtrCloudPointBuffer buffer, int quota) { int count = 0; if (m_partially_accepted) // gives the points that pass the test. { m_filter.PrepareForCell(Access.LowerLeft, Access.UpperRight, quota); while (quota > 0) { CloudPoint cp = Access.Points[m_halton_sequence[m_current_index++]]; if (m_filter.TestPoint(cp)) { buffer.AddCloudPoint(cp); count++; } quota--; } } else // gives all the points. { while (quota > 0) { buffer.AddCloudPoint(Access.Points[m_halton_sequence[m_current_index++]]); quota--; count++; } } return(count); }
/// <summary> /// Reads points from the node. /// </summary> /// <param name="filter">The filter that determines which point is to be read</param> /// <param name="buffer">The buffer to contain the points</param> /// <param name="start_index">The index of points to start fetching</param> /// <returns>The number of points that are fetched</returns> public int ReadPoints(PointCloudFilter filter, IntPtrCloudPointBuffer buffer, int start_index) { if (start_index == 0) { OctreeIndexSetIteratorList.Initialize(filter); OctreeIndexSetIteratorList.PrepareIterators(this); } return(OctreeIndexSetIteratorList.ReadPoints(buffer)); }
/// <summary> /// Reads points in the access and store them in the given buffer. /// </summary> /// <param name="buffer">The buffer pointer to store the points</param> /// <param name="buffer_size">The buffer size</param> /// <returns>The number of the points that are stored in the buffer</returns> public int ReadPoints(IntPtr buffer, int buffer_size) { int found = 0; if (m_done) { return(0); } IntPtrCloudPointBuffer cp_buffer = new IntPtrCloudPointBuffer(buffer, buffer_size); found = m_access.ReadPoints(m_filter, cp_buffer, m_current_index); m_current_index += found; if (m_current_index == m_access.Count || found == 0) { m_done = true; } return(found); }
/// <summary> /// Fetches the points from iterators and accumulates them the buffer. /// It calculates the portion of the points based on the buffer size and total number of the points, /// so each iterator gives the identical portion of their points (not exactly identical, because the number of points is integer). /// This allows us to give the points to Revit in approximately uniform. /// </summary> /// <param name="buffer">The buffer to contains the points</param> /// <returns>The number of the points that are read</returns> public static int ReadPoints(IntPtrCloudPointBuffer buffer) { int point_count = 0; double quota_ratio = Math.Min((double)buffer.Size / s_remaining_points, 1.0); while (s_iterator_list.Any() && buffer.Remaining > 0) { s_current_iterator_index %= s_iterator_list.Count; OctreeIndexSetIterator it = s_iterator_list[s_current_iterator_index]; int quota = (int)Math.Ceiling(Math.Min(quota_ratio * it.Remaining, buffer.Remaining)); point_count += it.ReadPoints(buffer, quota); if (it.Done) { s_iterator_list.RemoveAt(s_current_iterator_index); continue; } s_current_iterator_index++; } s_remaining_points -= point_count; return(point_count); }
/// <summary> /// Reads points from the cells. /// </summary> /// <param name="filter">The filter that determines which point is to be read</param> /// <param name="buffer">The buffer to contain the points</param> /// <param name="start_index">The index of points to start fetching</param> /// <returns>The number of points that are fetched</returns> protected override int ReadPoints(PointCloudFilter filter, IntPtrCloudPointBuffer buffer, int start_index) { int point_index = 0; int current_index = start_index; int total_points = 0; int start_cell = 0; for (int k = 0; k < m_cells.Length; k++) { UniformGridCell cell = m_cells[k]; int filter_result = filter.TestCell(cell.LowerLeft, cell.UpperRight); if (filter_result == -1) { continue; } total_points += cell.Count; if (current_index < total_points) { start_cell = k; current_index = Math.Max(0, start_index - total_points); break; } } for (int k = start_cell; k < m_cells.Length; k++) { UniformGridCell cell = m_cells[k]; int filter_result = filter.TestCell(cell.LowerLeft, cell.UpperRight); if (filter_result == -1) { continue; } if (filter_result == 0) { filter.PrepareForCell(m_outline.MinimumPoint, m_outline.MaximumPoint, cell.Count); } for (int s = current_index; s < cell.Count; s++) { if (filter_result == 0) { if (filter.TestPoint(m_points[cell.Indices[s]]) == false) { continue; } } buffer.AddCloudPoint(m_points[cell.Indices[s]]); point_index++; if (point_index >= buffer.Size) { break; } } if (point_index >= buffer.Size) { break; } current_index = 0; } return(point_index); }
/// <summary> /// Reads the points in this container. /// </summary> /// <param name="filter">The filter</param> /// <param name="buffer">The buffer to store the points that are read</param> /// <param name="start_index">The index of the point to start reading</param> /// <returns>The number of points that are read</returns> protected virtual int ReadPoints(PointCloudFilter filter, IntPtrCloudPointBuffer buffer, int start_index) { throw new NotImplementedException(); }
/// <summary> /// Reads points from the root. /// </summary> /// <param name="filter">The filter that determines which point is to be read</param> /// <param name="buffer">The buffer to contain the points</param> /// <param name="start_index">The index of points to start fetching</param> /// <returns>The number of points that are fetched</returns> protected override int ReadPoints(PointCloudFilter filter, IntPtrCloudPointBuffer buffer, int start_index) => m_root.ReadPoints(filter, buffer, start_index);