C++ BoundBox3d::Add方法代码示例

Base::Vector3d TransformStrategy::getRotationCenter() const
{
    // get the global bounding box of all selected objects and use its center as
    // rotation center
    std::set<App::DocumentObject*> objects = transformObjects();
    if (!objects.empty()) {
        Base::BoundBox3d bbox;
        bool first=true;
        for (std::set<App::DocumentObject*>::const_iterator it=objects.begin();it!=objects.end();++it) {
            std::map<std::string,App::Property*> props;
            (*it)->getPropertyMap(props);
            // search for a data property
            std::map<std::string,App::Property*>::iterator jt;
            jt = std::find_if(props.begin(), props.end(), find_geometry_data());
            if (jt != props.end()) {
                if (first)
                    bbox = (static_cast<App::PropertyGeometry*>(jt->second)->getBoundingBox());
                else
                    bbox.Add(static_cast<App::PropertyGeometry*>(jt->second)->getBoundingBox());
                first = false;
            }
        }

        return Base::Vector3d((bbox.MinX+bbox.MaxX)/2,
                              (bbox.MinY+bbox.MaxY)/2,
                              (bbox.MinZ+bbox.MaxZ)/2);
    }

    return Base::Vector3d();
}

Base::BoundBox3d PropertyPointKernel::getBoundingBox() const
{
    Base::BoundBox3d box;
    for (PointKernel::const_iterator it = _cPoints->begin(); it != _cPoints->end(); ++it)
        box.Add(*it);
    return box;
}

Base::BoundBox3d DrawProjGroup::getBoundingBox() const
{
    Base::BoundBox3d bbox;

    std::vector<App::DocumentObject*> views = Views.getValues();
    TechDraw::DrawProjGroupItem *anchorView = dynamic_cast<TechDraw::DrawProjGroupItem *>(Anchor.getValue());
    for (std::vector<App::DocumentObject*>::const_iterator it = views.begin(); it != views.end(); ++it) {
         if ((*it)->getTypeId().isDerivedFrom(DrawViewPart::getClassTypeId())) {
            DrawViewPart *part = static_cast<DrawViewPart *>(*it);
            Base::BoundBox3d  bb = part->getBoundingBox();

            bb.ScaleX(1. / part->Scale.getValue());
            bb.ScaleY(1. / part->Scale.getValue());

            // X and Y of dependant views are relative to the anchorView
            if (part != anchorView) {
                bb.MoveX(part->X.getValue());
                bb.MoveY(part->Y.getValue());
            }

            bbox.Add(bb);
        }
    }
    // This /should/ leave the centre of the bounding box at (0,0) except when
    // we're in the process of updating the anchor view's position (eg called
    // by moveToCentre())
    if (anchorView) { //TODO: It looks like we might be getting called before an anchor view is set - weird...
        bbox.MoveX(anchorView->X.getValue());
        bbox.MoveY(anchorView->Y.getValue());
    }
    return bbox;
}

Base::BoundBox3d PointKernel::getBoundBox(void)const
{
    Base::BoundBox3d bnd;
    for (const_point_iterator it = begin(); it != end(); ++it)
        bnd.Add(*it);
    return bnd;
}

    void onSelectionChanged(const Gui::SelectionChanges& msg)
    {
        Base::BoundBox3d bbox;
        unsigned long countPoints=0, countFacets=0;
        std::vector<Mesh::Feature*> mesh = Gui::Selection().getObjectsOfType<Mesh::Feature>();
        for (std::vector<Mesh::Feature*>::iterator it = mesh.begin(); it != mesh.end(); ++it) {
            countPoints += (*it)->Mesh.getValue().countPoints();
            countFacets += (*it)->Mesh.getValue().countFacets();
            bbox.Add((*it)->Mesh.getBoundingBox());
        }

        if (countPoints > 0) {
            numPoints->setText(QString::number(countPoints));
            numFacets->setText(QString::number(countFacets));
            numMin->setText(QString::fromAscii("X: %1\tY: %2\tZ: %3")
                .arg(bbox.MinX).arg(bbox.MinX).arg(bbox.MinX));
            numMax->setText(QString::fromAscii("X: %1\tY: %2\tZ: %3")
                .arg(bbox.MaxX).arg(bbox.MaxX).arg(bbox.MaxX));
        }
        else {
            numPoints->setText(QString::fromAscii(""));
            numFacets->setText(QString::fromAscii(""));
            numMin->setText(QString::fromAscii(""));
            numMax->setText(QString::fromAscii(""));
        }
    }

Base::BoundBox3d GeometryObject::boundingBoxOfAoe(const Ellipse *aoe,
        double start,
        double end, bool cw) const
{
    // Using the ellipse form:
    // (xc, yc) = centre of ellipse
    // phi = angle of ellipse major axis off X axis
    // a, b = half of major, minor axes
    //
    // x(theta) = xc + a*cos(theta)*cos(phi) - b*sin(theta)*sin(phi)
    // y(theta) = yc + a*cos(theta)*sin(phi) + b*sin(theta)*cos(phi)

    double a (aoe->major / 2.0),
           b (aoe->minor / 2.0),
           phi (aoe->angle),
           xc (aoe->center.fX),
           yc (aoe->center.fY);

    if (a == 0 || b == 0) {
        // Degenerate case - TODO: handle as line instead of throwing
        throw Base::Exception("Ellipse with invalid major axis in GeometryObject::boundingBoxOfAoe()");
    }

    // Calculate points of interest for the bounding box.  These are points
    // where d(x)/d(theta) and d(y)/d(theta) = 0 (where the x and y extremes
    // of the ellipse would be if it were complete), and arc endpoints.
    double testAngles[6] = { atan(tan(phi) * (-b / a)),
                             testAngles[0] + M_PI
                           };
    if (tan(phi) == 0) {
        testAngles[2] = M_PI / 2.0;
        testAngles[3] = 3.0 * M_PI / 2.0;
    } else {
        testAngles[2] = atan((1.0 / tan(phi)) * (b / a));
        testAngles[3] = testAngles[2] + M_PI;
    }
    testAngles[4] = start;
    testAngles[5] = end;

    // Add extremes to bounding box, if they are within the arc
    Base::BoundBox3d bb;
    for (int ai(0); ai < 6; ++ai) {
        double theta(testAngles[ai]);
        if (isWithinArc(theta, start, end, cw) ) {
            bb.Add( Base::Vector3d(xc + a*cos(theta)*cos(phi) - b*sin(theta)*sin(phi),
                                   yc + a*cos(theta)*sin(phi) - b*sin(theta)*cos(phi),
                                   0) );
        }
    }

    return bb;
}

PointsGrid::PointsGrid (const PointKernel &rclM, double fGridLen)
: _pclPoints(&rclM),
  _ulCtElements(0),
  _ulCtGridsX(0), _ulCtGridsY(0), _ulCtGridsZ(0),
  _fGridLenX(0.0f), _fGridLenY(0.0f), _fGridLenZ(0.0f),
  _fMinX(0.0f), _fMinY(0.0f), _fMinZ(0.0f)
{
  Base::BoundBox3d clBBPts;// = _pclPoints->GetBoundBox();
  for (PointKernel::const_iterator it = _pclPoints->begin(); it != _pclPoints->end(); ++it )
    clBBPts.Add(*it);
  Rebuild(std::max<unsigned long>((unsigned long)(clBBPts.LengthX() / fGridLen), 1),
          std::max<unsigned long>((unsigned long)(clBBPts.LengthY() / fGridLen), 1),
          std::max<unsigned long>((unsigned long)(clBBPts.LengthZ() / fGridLen), 1));
}

void PointsGrid::InitGrid (void)
{
  assert(_pclPoints != NULL);

  unsigned long i, j;

  // Grid Laengen berechnen wenn nicht initialisiert
  //
  if ((_ulCtGridsX == 0) || (_ulCtGridsY == 0) || (_ulCtGridsZ == 0))
    CalculateGridLength(POINTS_CT_GRID, POINTS_MAX_GRIDS);

  // Grid Laengen und Offset bestimmen
  //
  {
  Base::BoundBox3d clBBPts;// = _pclPoints->GetBoundBox();
  for (PointKernel::const_iterator it = _pclPoints->begin(); it != _pclPoints->end(); ++it )
    clBBPts.Add(*it);

  double fLengthX = clBBPts.LengthX(); 
  double fLengthY = clBBPts.LengthY();
  double fLengthZ = clBBPts.LengthZ();

  {
    // Offset fGridLen/2
    //
    _fGridLenX = (1.0f + fLengthX) / double(_ulCtGridsX);
    _fMinX = clBBPts.MinX - 0.5f;
  }

  {
    _fGridLenY = (1.0f + fLengthY) / double(_ulCtGridsY);
    _fMinY = clBBPts.MinY - 0.5f;
  }

  {
    _fGridLenZ = (1.0f + fLengthZ) / double(_ulCtGridsZ);
    _fMinZ = clBBPts.MinZ - 0.5f;
  }
  }

  // Daten-Struktur anlegen
  _aulGrid.clear();
  _aulGrid.resize(_ulCtGridsX);
  for (i = 0; i < _ulCtGridsX; i++)
  {
    _aulGrid[i].resize(_ulCtGridsY);
    for (j = 0; j < _ulCtGridsY; j++)
      _aulGrid[i][j].resize(_ulCtGridsZ);
  }
}

Base::BoundBox3d PointKernel::getBoundBox(void)const
{
    Base::BoundBox3d bnd;

    //FIXME: VS 2015 or later causes a linker error
#if defined _WIN32 
    // Thread-local bounding boxes
    Concurrency::combinable<Base::BoundBox3d> bbs;
    // Cannot use a const_point_iterator here as it is *not* a proper iterator (fails the for_each template)
    Concurrency::parallel_for_each(_Points.begin(), _Points.end(), [this, &bbs](const value_type& value) {
        Base::Vector3d vertd(value.x, value.y, value.z);
        bbs.local().Add(this->_Mtrx * vertd);
    });
    // Combine each thread-local bounding box in the final bounding box
    bbs.combine_each([&bnd](const Base::BoundBox3d& lbb) {
        bnd.Add(lbb);
    });
#else
    for (const_point_iterator it = begin(); it != end(); ++it)
        bnd.Add(*it);
#endif
    return bnd;
}

void CmdPartCrossSections::activated(int iMsg)
{
    Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
    if (!dlg) {
        std::vector<App::DocumentObject*> obj = Gui::Selection().getObjectsOfType
            (Part::Feature::getClassTypeId());
        Base::BoundBox3d bbox;
        for (std::vector<App::DocumentObject*>::iterator it = obj.begin(); it != obj.end(); ++it) {
            bbox.Add(static_cast<Part::Feature*>(*it)->Shape.getBoundingBox());
        }
        dlg = new PartGui::TaskCrossSections(bbox);
    }
    Gui::Control().showDialog(dlg);
}

void PointsGrid::CalculateGridLength (unsigned long ulCtGrid, unsigned long ulMaxGrids)
{
  // Grid Laengen bzw. Anzahl der Grids pro Dimension berechnen
  // pro Grid sollen ca. 10 (?!?!) Facets liegen
  // bzw. max Grids sollten 10000 nicht ueberschreiten
  Base::BoundBox3d clBBPtsEnlarged;// = _pclPoints->GetBoundBox();
  for (PointKernel::const_iterator it = _pclPoints->begin(); it != _pclPoints->end(); ++it )
    clBBPtsEnlarged.Add(*it);
  double fVolElem;

  if (_ulCtElements > (ulMaxGrids * ulCtGrid))
    fVolElem = (clBBPtsEnlarged.LengthX() * clBBPtsEnlarged.LengthY() * clBBPtsEnlarged.LengthZ()) / float(ulMaxGrids * ulCtGrid);
  else
    fVolElem = (clBBPtsEnlarged.LengthX() * clBBPtsEnlarged.LengthY() * clBBPtsEnlarged.LengthZ()) / float(_ulCtElements);

  double fVol     = fVolElem * float(ulCtGrid);
  double fGridLen = float(pow((float)fVol,(float) 1.0f / 3.0f));

  _ulCtGridsX = std::max<unsigned long>((unsigned long)(clBBPtsEnlarged.LengthX() / fGridLen), 1);
  _ulCtGridsY = std::max<unsigned long>((unsigned long)(clBBPtsEnlarged.LengthY() / fGridLen), 1);
  _ulCtGridsZ = std::max<unsigned long>((unsigned long)(clBBPtsEnlarged.LengthZ() / fGridLen), 1);
}

Base::BoundBox3d GeometryObject::calcBoundingBox() const
{
    Base::BoundBox3d bbox;

    // First calculate bounding box based on vertices
    for(std::vector<Vertex *>::const_iterator it( vertexGeom.begin() );
            it != vertexGeom.end(); ++it) {
        bbox.Add( Base::Vector3d((*it)->pnt.fX, (*it)->pnt.fY, 0.) );
    }

    // Now, consider geometry where vertices don't define bounding box eg circles
    for (std::vector<BaseGeom *>::const_iterator it( edgeGeom.begin() );
            it != edgeGeom.end(); ++it) {
        switch ((*it)->geomType) {
        case CIRCLE: {
            Circle *c = static_cast<Circle *>(*it);
            bbox.Add( Base::BoundBox3d(-c->radius + c->center.fX,
                                       -c->radius + c->center.fY,
                                       0,
                                       c->radius + c->center.fX,
                                       c->radius + c->center.fY,
                                       0) );
        }
        break;

        case ARCOFCIRCLE: {
            AOC *arc = static_cast<AOC *>(*it);

            // Endpoints of arc
            bbox.Add( Base::Vector3d(arc->radius * cos(arc->startAngle),
                                     arc->radius * sin(arc->startAngle),
                                     0.0) );
            bbox.Add( Base::Vector3d(arc->radius * cos(arc->endAngle),
                                     arc->radius * sin(arc->endAngle),
                                     0.0) );

            // Extreme X and Y values if they're within the arc
            for (double theta = 0.0; theta < 6.5; theta += M_PI / 2.0) {
                if (isWithinArc(theta, arc->startAngle, arc->endAngle, arc->cw)) {
                    bbox.Add( Base::Vector3d(arc->radius * cos(theta),
                                             arc->radius * sin(theta),
                                             0.0) );
                }
            }
        }
        break;

        case ELLIPSE: {
            bbox.Add( boundingBoxOfAoe(static_cast<Ellipse *>(*it)) );
        }
        break;

        case ARCOFELLIPSE: {
            AOE *aoe = static_cast<AOE *>(*it);
            double start = aoe->startAngle,
                   end = aoe->endAngle;
            bool cw = aoe->cw;
            bbox.Add( boundingBoxOfAoe(static_cast<Ellipse *>(*it), start, end, cw) );
        }
        break;

        case BSPLINE: {
            bbox.Add( boundingBoxOfBspline(static_cast<BSpline *>(*it)) );
        }
        break;

        case GENERIC: {
            // this case ends up just drawing line segments between points
            Generic *gen = static_cast<Generic *>(*it);
            for (std::vector<Base::Vector2D>::const_iterator segIt = gen->points.begin();
                    segIt != gen->points.end(); ++segIt) {
                bbox.Add( Base::Vector3d(segIt->fX, segIt->fY, 0) );
            }
        }
        break;

        default:
            throw Base::Exception("Unknown geomType in GeometryObject::calcBoundingBox()");
        }
    }
    return bbox;
}

Base::BoundBox3d GeometryObject::boundingBoxOfBspline(const BSpline *spline) const
{
    Base::BoundBox3d bb;
    for (std::vector<BezierSegment>::const_iterator segItr( spline->segments.begin() );
            segItr != spline->segments.end(); ++segItr) {
        switch (segItr->poles) {
        case 0:   // Degenerate, but safe ignore
            break;
        case 2:   // Degenerate - straight line
            bb.Add(Base::Vector3d( segItr->pnts[1].fX,
                                   segItr->pnts[1].fY,
                                   0 ));
        // fall through
        case 1:   // Degenerate - just a point
            bb.Add(Base::Vector3d( segItr->pnts[0].fX,
                                   segItr->pnts[0].fY,
                                   0 ));
            break;
        case 3: {
            double
            px[3] = { segItr->pnts[0].fX,
                      segItr->pnts[1].fX,
                      segItr->pnts[2].fX
                    },
                    py[3] = { segItr->pnts[0].fY,
                              segItr->pnts[1].fY,
                              segItr->pnts[2].fY
                            },
                            slns[4] = { 0, 1 }; // Consider the segment's end points

            // if's are to prevent problems with divide-by-0
            if ((2 * px[1] - px[0] - px[2]) == 0) {
                slns[2] = -1;
            } else {
                slns[2] = (px[1] - px[0]) / (2 * px[1] - px[0] - px[2]);
            }
            if ((2 * py[1] - py[0] - py[2]) == 0) {
                slns[3] = -1;
            } else {
                slns[3] = (py[1] - py[0]) / (2 * py[1] - py[0] - py[2]);
            }

            // evaluate B(t) at the endpoints and zeros
            for (int s(0); s < 4; ++s) {
                double t( slns[s] );
                if (t < 0 || t > 1) {
                    continue;
                }
                double tx( px[0] * (1 - t) * (1 - t) +
                           px[1] * 2 * (1 - t) * t +
                           px[2] * t * t ),
                           ty( py[0] * (1 - t) * (1 - t) +
                               py[1] * 2 * (1 - t) * t +
                               py[2] * t * t );
                bb.Add( Base::Vector3d(tx, ty, 0) );
            }
        }
        break;
        case 4: {
            double
            px[4] = { segItr->pnts[0].fX,
                      segItr->pnts[1].fX,
                      segItr->pnts[2].fX,
                      segItr->pnts[3].fX
                    },
                    py[4] = { segItr->pnts[0].fY,
                              segItr->pnts[1].fY,
                              segItr->pnts[2].fY,
                              segItr->pnts[3].fY
                            },
                            // If B(t) is the cubic Bezier, find t where B'(t) == 0
                            //
                            // For control points P0-P3, B'(t) works out to be:
                            // B'(t) = t^2 * (-3P0 + 9P1 - 9P2 + 3P3) +
                            //          t  * (6P0 - 12P1 + 6P2) +
                            //          3  * (P1 - P0)
                            //
                            // So, we use the quadratic formula!
                            ax = -3 * px[0] + 9 * px[1] - 9 * px[2] + 3 * px[3],
                            ay = -3 * py[0] + 9 * py[1] - 9 * py[2] + 3 * py[3],
                            bx = 6 * px[0] - 12 * px[1] + 6 * px[2],
                            by = 6 * py[0] - 12 * py[1] + 6 * py[2],
                            cx = 3 * px[1] - 3 * px[0],
                            cy = 3 * py[1] - 3 * py[0],

                            slns[6] = { 0, 1 }; // Consider the segment's end points

            // if's are to prevent problems with divide-by-0 and NaN
            if ( (2 * ax) == 0 || (bx * bx - 4 * ax * cx) < 0 ) {
                slns[2] = -1;
                slns[3] = -1;
            } else {
                slns[2] = (-bx + sqrt(bx * bx - 4 * ax * cx)) / (2 * ax);
                slns[3] = (-bx - sqrt(bx * bx - 4 * ax * cx)) / (2 * ax);
            }
            if ((2 * ay) == 0 || (by * by - 4 * ay * cy) < 0 ) {
                slns[4] = -1;
                slns[5] = -1;
            } else {
                slns[4] = (-by + sqrt(by * by - 4 * ay * cy)) / (2 * ay);
//.........这里部分代码省略.........