Example #1
0
void
NodeOverlap::getSourceBoxContainer(hier::BoxContainer& src_boxes) const
{
   TBOX_ASSERT(src_boxes.empty());

   src_boxes = d_dst_boxes;
   if (!src_boxes.empty()) {
      const tbox::Dimension& dim = src_boxes.front().getDim();
      for (hier::BoxContainer::iterator bi = src_boxes.begin();
           bi != src_boxes.end(); ++bi) {
         bi->setUpper(bi->upper() - hier::IntVector::getOne(dim));
         d_transformation.inverseTransform(*bi);
         bi->setUpper(bi->upper() + hier::IntVector::getOne(dim));
      }
   }
}
Example #2
0
/*
 *************************************************************************
 *
 * Set up a EdgeOverlap oject using the given boxes and offset
 *
 *************************************************************************
 */
std::shared_ptr<hier::BoxOverlap>
OuteredgeGeometry::setUpOverlap(
   const hier::BoxContainer& boxes,
   const hier::Transformation& transformation) const
{
   const tbox::Dimension& dim(transformation.getOffset().getDim());
   std::vector<hier::BoxContainer> dst_boxes(dim.getValue());

   for (hier::BoxContainer::const_iterator b = boxes.begin();
        b != boxes.end(); ++b) {
      for (int d = 0; d < dim.getValue(); ++d) {
         hier::Box edge_box(EdgeGeometry::toEdgeBox(*b, d));
         dst_boxes[d].pushBack(edge_box);
      }
   }

   // Create the edge overlap data object using the boxes and transformation
   return std::make_shared<EdgeOverlap>(dst_boxes, transformation);

}
Example #3
0
/*
 *************************************************************************
 *
 * Set up a FaceOverlap oject using the given boxes and offset
 *
 *************************************************************************
 */
boost::shared_ptr<hier::BoxOverlap>
OuterfaceGeometry::setUpOverlap(
   const hier::BoxContainer& boxes,
   const hier::Transformation& transformation) const
{
   const tbox::Dimension& dim(transformation.getOffset().getDim());
   std::vector<hier::BoxContainer> dst_boxes(dim.getValue());

   for (hier::BoxContainer::const_iterator b = boxes.begin();
        b != boxes.end(); ++b) {
      for (tbox::Dimension::dir_t d = 0; d < dim.getValue(); ++d) {
         hier::Box face_box(FaceGeometry::toFaceBox(*b, d));
         dst_boxes[d].pushBack(face_box);
      }
   }

   // Create the face overlap data object using the boxes and source shift
   return boost::make_shared<FaceOverlap>(dst_boxes, transformation);

}
Example #4
0
std::shared_ptr<hier::BoxOverlap>
OuteredgeGeometry::doOverlap(
   const OuteredgeGeometry& dst_geometry,
   const OuteredgeGeometry& src_geometry,
   const hier::Box& src_mask,
   const hier::Box& fill_box,
   const bool overwrite_interior,
   const hier::Transformation& transformation,
   const hier::BoxContainer& dst_restrict_boxes)
{

   const tbox::Dimension& dim(src_mask.getDim());

   std::vector<hier::BoxContainer> dst_boxes(dim.getValue());

   // Perform a quick-and-dirty intersection to see if the boxes might overlap

   const hier::Box src_box(
      hier::Box::grow(src_geometry.d_box, src_geometry.d_ghosts) * src_mask);
   hier::Box src_box_shifted(src_box);
   transformation.transform(src_box_shifted);
   const hier::Box dst_box(
      hier::Box::grow(dst_geometry.getBox(), dst_geometry.getGhosts()));

   // Compute the intersection (if any) for each of the edge directions

   const hier::IntVector one_vector(dim, 1);

   bool quick_boxes_intersect =
      (hier::Box::grow(src_box_shifted, one_vector)).intersects(
         hier::Box::grow(dst_box, one_vector));
   if (quick_boxes_intersect) {

      for (tbox::Dimension::dir_t axis = 0; axis < dim.getValue(); ++axis) {

         const hier::Box dst_edge_box(
            EdgeGeometry::toEdgeBox(dst_box, axis));
         const hier::Box src_edge_box(
            EdgeGeometry::toEdgeBox(src_box_shifted, axis));

         bool boxes_intersect = dst_edge_box.intersects(src_edge_box);

         if (boxes_intersect) {

            const hier::Box fill_edge_box(
               EdgeGeometry::toEdgeBox(fill_box, axis));

            for (tbox::Dimension::dir_t src_face_normal = 0;
                 src_face_normal < dim.getValue();
                 ++src_face_normal) {

               if (src_face_normal != axis) {

                  hier::Box outeredge_src_box_lo(toOuteredgeBox(
                                                    src_box_shifted,
                                                    axis,
                                                    src_face_normal,
                                                    0));
                  hier::Box outeredge_src_box_up(toOuteredgeBox(
                                                    src_box_shifted,
                                                    axis,
                                                    src_face_normal,
                                                    1));

                  for (tbox::Dimension::dir_t dst_face_normal = 0;
                       dst_face_normal < dim.getValue();
                       ++dst_face_normal) {

                     if (dst_face_normal != axis) {

                        hier::Box outeredge_dst_box_lo(toOuteredgeBox(dst_box,
                                                          axis,
                                                          dst_face_normal,
                                                          0));
                        hier::Box outeredge_dst_box_up(toOuteredgeBox(dst_box,
                                                          axis,
                                                          dst_face_normal,
                                                          1));

                        outeredge_dst_box_lo =
                           outeredge_dst_box_lo * fill_edge_box;
                        outeredge_dst_box_up =
                           outeredge_dst_box_up * fill_edge_box;

                        hier::Box lo_lo_box(
                           outeredge_src_box_lo * outeredge_dst_box_lo);
                        if (!lo_lo_box.empty()) {
                           dst_boxes[axis].pushBack(lo_lo_box);
                        }

                        hier::Box lo_up_box(
                           outeredge_src_box_lo * outeredge_dst_box_up);
                        if (!lo_up_box.empty()) {
                           dst_boxes[axis].pushBack(lo_up_box);
                        }

                        hier::Box up_lo_box(
                           outeredge_src_box_up * outeredge_dst_box_lo);
                        if (!up_lo_box.empty()) {
                           dst_boxes[axis].pushBack(up_lo_box);
                        }

                        hier::Box up_up_box(
                           outeredge_src_box_up * outeredge_dst_box_up);
                        if (!up_up_box.empty()) {
                           dst_boxes[axis].pushBack(up_up_box);
                        }

                     }  // dst data undefined when dst_face_normal == axis

                  }  // iterate over dst face normal directions

               }  // src data undefined when src_face_normal == axis

            }  // iterate over src face normal directions

         }  // if source and destination edge boxes overlap in axis direction

         if (!overwrite_interior) {
            const hier::Box interior_edges(
               EdgeGeometry::toEdgeBox(dst_geometry.getBox(),
                  axis));
            dst_boxes[axis].removeIntersections(interior_edges);
         }

         if (!dst_restrict_boxes.empty() && !dst_boxes[axis].empty()) {
            hier::BoxContainer edge_restrict_boxes;
            for (hier::BoxContainer::const_iterator b = dst_restrict_boxes.begin();
                 b != dst_restrict_boxes.end(); ++b) {
               edge_restrict_boxes.pushBack(EdgeGeometry::toEdgeBox(*b, axis));
            }
            dst_boxes[axis].intersectBoxes(edge_restrict_boxes);
         }

      }  // iterate over axis directions

   }  // if quick check passes

   // Create the edge overlap data object using the boxes and source shift
   return std::make_shared<EdgeOverlap>(dst_boxes, transformation);
}
Example #5
0
boost::shared_ptr<hier::BoxOverlap>
OuterfaceGeometry::doOverlap(
   const OuterfaceGeometry& dst_geometry,
   const OuterfaceGeometry& src_geometry,
   const hier::Box& src_mask,
   const hier::Box& fill_box,
   const bool overwrite_interior,
   const hier::Transformation& transformation,
   const hier::BoxContainer& dst_restrict_boxes)
{
   const tbox::Dimension& dim(src_mask.getDim());

   std::vector<hier::BoxContainer> dst_boxes(dim.getValue());

   // Perform a quick-and-dirty intersection to see if the boxes might overlap

   hier::Box src_box(src_geometry.d_box);
   src_box.grow(src_geometry.d_ghosts);
   src_box = src_box * src_mask;
   transformation.transform(src_box);
   hier::Box dst_ghost(dst_geometry.getBox());
   dst_ghost.grow(dst_geometry.getGhosts());

   // Compute the intersection (if any) for each of the face directions

   const hier::IntVector one_vector(dim, 1);

   const hier::Box quick_check(
      hier::Box::grow(src_box, one_vector) * hier::Box::grow(dst_ghost,
         one_vector));

   if (!quick_check.empty()) {

      hier::Box mask_shift(src_mask);
      transformation.transform(mask_shift);

      for (tbox::Dimension::dir_t d = 0; d < dim.getValue(); ++d) {

         const hier::Box dst_face(
            FaceGeometry::toFaceBox(dst_geometry.getBox(), d));
         const hier::Box src_face(
            FaceGeometry::toFaceBox(src_box, d));
         const hier::Box fill_face(
            FaceGeometry::toFaceBox(fill_box, d));

         const hier::Box together(dst_face * src_face * fill_face);

         if (!together.empty()) {

            const hier::Box msk_face(
               FaceGeometry::toFaceBox(mask_shift, d));

            hier::Box low_dst_face(dst_face);
            low_dst_face.setUpper(0, low_dst_face.lower(0));
            hier::Box hig_dst_face(dst_face);
            hig_dst_face.setLower(0, hig_dst_face.upper(0));

            // Add lower face intersection (if any) to the box list
            hier::Box low_src_face(src_face);
            low_src_face.setUpper(0, low_src_face.lower(0));

            hier::Box low_low_overlap(low_src_face * msk_face * low_dst_face);
            if (!low_low_overlap.empty()) {
               dst_boxes[d].pushBack(low_low_overlap);
            }

            hier::Box low_hig_overlap(low_src_face * msk_face * hig_dst_face);
            if (!low_hig_overlap.empty()) {
               dst_boxes[d].pushBack(low_hig_overlap);
            }

            // Add upper face intersection (if any) to the box list
            hier::Box hig_src_face(src_face);
            hig_src_face.setLower(0, hig_src_face.upper(0));  //-ghosts;

            hier::Box hig_low_overlap(hig_src_face * msk_face * low_dst_face);
            if (!hig_low_overlap.empty()) {
               dst_boxes[d].pushBack(hig_low_overlap);
            }

            hier::Box hig_hig_overlap(hig_src_face * msk_face * hig_dst_face);
            if (!hig_hig_overlap.empty()) {
               dst_boxes[d].pushBack(hig_hig_overlap);
            }

            // Take away the interior of over_write interior is not set
            if (!overwrite_interior) {
               dst_boxes[d].removeIntersections(
                  FaceGeometry::toFaceBox(dst_geometry.getBox(), d));
            }

         }  // if (!together.empty())

         if (!dst_restrict_boxes.empty() && !dst_boxes[d].empty()) {
            hier::BoxContainer face_restrict_boxes;
            for (hier::BoxContainer::const_iterator b = dst_restrict_boxes.begin();
                 b != dst_restrict_boxes.end(); ++b) {
               face_restrict_boxes.pushBack(FaceGeometry::toFaceBox(*b, d));
            }
            dst_boxes[d].intersectBoxes(face_restrict_boxes);
         }

         dst_boxes[d].coalesce();

      }  // loop over dim

   } // if (!quick_check.empty())

   // Create the face overlap data object using the boxes and source shift

   return boost::make_shared<FaceOverlap>(dst_boxes, transformation);
}