vrshoot: b2f14e535253 libs/assimp/IFCCurve.cpp

301 cnt += entry.first->EstimateSampleCount( entry.second ? at + range.first : range.second - bt, entry.second ? bt + range.first : range.second - at );

302 }

303

304 acc += delta;

305 }

306

307 return cnt;

308 }

309

310 // --------------------------------------------------

311 void SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const

312 {

313 ai_assert(InRange(a) && InRange(b));

314

315 const size_t cnt = EstimateSampleCount(a,b);

316 out.verts.reserve(out.verts.size() + cnt);

317

318 BOOST_FOREACH(const CurveEntry& entry, curves) {

319 const size_t cnt = out.verts.size();

320 entry.first->SampleDiscrete(out);

321

322 if (!entry.second && cnt != out.verts.size()) {

323 std::reverse(out.verts.begin()+cnt,out.verts.end());

324 }

325 }

326 }

327

328 // --------------------------------------------------

329 ParamRange GetParametricRange() const {

330 return std::make_pair(static_cast<IfcFloat>( 0. ),total);

331 }

332

333 private:

334 const IfcCompositeCurve& entity;

335 std::vector< CurveEntry > curves;

336

337 IfcFloat total;

338 };

339

340

341 // --------------------------------------------------------------------------------

342 // TrimmedCurve can be used to trim an unbounded curve to a bounded range

343 // --------------------------------------------------------------------------------

344 class TrimmedCurve : public BoundedCurve

345 {

346

347 public:

348

349 // --------------------------------------------------

350 TrimmedCurve(const IfcTrimmedCurve& entity, ConversionData& conv)

351 : BoundedCurve(entity,conv)

352 , entity(entity)

353 , ok()

354 {

355 base = boost::shared_ptr<const Curve>(Curve::Convert(entity.BasisCurve,conv));

356

357 typedef boost::shared_ptr<const STEP::EXPRESS::DataType> Entry;

358

359 // for some reason, trimmed curves can either specify a parametric value

360 // or a point on the curve, or both. And they can even specify which of the

361 // two representations they prefer, even though an information invariant

362 // claims that they must be identical if both are present.

363 // oh well.

364 bool have_param = false, have_point = false;

365 IfcVector3 point;

366 BOOST_FOREACH(const Entry sel,entity.Trim1) {

367 if (const EXPRESS::REAL* const r = sel->ToPtr<EXPRESS::REAL>()) {

368 range.first = *r;

369 have_param = true;

370 break;

371 }

372 else if (const IfcCartesianPoint* const r = sel->ResolveSelectPtr<IfcCartesianPoint>(conv.db)) {

373 ConvertCartesianPoint(point,*r);

374 have_point = true;

375 }

376 }

377 if (!have_param) {

378 if (!have_point || !base->ReverseEval(point,range.first)) {

379 throw CurveError("IfcTrimmedCurve: failed to read first trim parameter, ignoring curve");

380 }

381 }

382 have_param = false, have_point = false;

383 BOOST_FOREACH(const Entry sel,entity.Trim2) {

384 if (const EXPRESS::REAL* const r = sel->ToPtr<EXPRESS::REAL>()) {

385 range.second = *r;

386 have_param = true;

387 break;

388 }

389 else if (const IfcCartesianPoint* const r = sel->ResolveSelectPtr<IfcCartesianPoint>(conv.db)) {

390 ConvertCartesianPoint(point,*r);

391 have_point = true;

392 }

393 }

394 if (!have_param) {

395 if (!have_point || !base->ReverseEval(point,range.second)) {

396 throw CurveError("IfcTrimmedCurve: failed to read second trim parameter, ignoring curve");

397 }

398 }

399

400 agree_sense = IsTrue(entity.SenseAgreement);

401 if( !agree_sense ) {

402 std::swap(range.first,range.second);

403 }

404

405 // "NOTE In case of a closed curve, it may be necessary to increment t1 or t2

406 // by the parametric length for consistency with the sense flag."

407 if (base->IsClosed()) {

408 if( range.first > range.second ) {

409 range.second += base->GetParametricRangeDelta();

410 }

411 }

412

413 maxval = range.second-range.first;

414 ai_assert(maxval >= 0);

415 }

416

417 public:

418

419 // --------------------------------------------------

420 IfcVector3 Eval(IfcFloat p) const {

421 ai_assert(InRange(p));

422 return base->Eval( TrimParam(p) );

423 }

424

425 // --------------------------------------------------

426 size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {

427 ai_assert(InRange(a) && InRange(b));

428 return base->EstimateSampleCount(TrimParam(a),TrimParam(b));

429 }

430

431 // --------------------------------------------------

432 void SampleDiscrete(TempMesh& out,IfcFloat a,IfcFloat b) const {

433 ai_assert(InRange(a) && InRange(b));

434 return base->SampleDiscrete(out,TrimParam(a),TrimParam(b));

435 }

436

437 // --------------------------------------------------

438 ParamRange GetParametricRange() const {

439 return std::make_pair(static_cast<IfcFloat>( 0. ),maxval);

440 }

441

442 private:

443

444 // --------------------------------------------------

445 IfcFloat TrimParam(IfcFloat f) const {

446 return agree_sense ? f + range.first : range.second - f;

447 }

448

449

450 private:

451 const IfcTrimmedCurve& entity;

452 ParamRange range;

453 IfcFloat maxval;

454 bool agree_sense;

455 bool ok;

456

457 boost::shared_ptr<const Curve> base;

458 };

459

460

461 // --------------------------------------------------------------------------------

462 // PolyLine is a 'curve' defined by linear interpolation over a set of discrete points

463 // --------------------------------------------------------------------------------

464 class PolyLine : public BoundedCurve

465 {

466

467 public:

468

469 // --------------------------------------------------

470 PolyLine(const IfcPolyline& entity, ConversionData& conv)

471 : BoundedCurve(entity,conv)

472 , entity(entity)

473 {

474 points.reserve(entity.Points.size());

475

476 IfcVector3 t;

477 BOOST_FOREACH(const IfcCartesianPoint& cp, entity.Points) {

478 ConvertCartesianPoint(t,cp);

479 points.push_back(t);

480 }

481 }

482

483 public:

484

485 // --------------------------------------------------

486 IfcVector3 Eval(IfcFloat p) const {

487 ai_assert(InRange(p));

488

489 const size_t b = static_cast<size_t>(floor(p));

490 if (b == points.size()-1) {

491 return points.back();

492 }

493

494 const IfcFloat d = p-static_cast<IfcFloat>(b);

495 return points[b+1] * d + points[b] * (static_cast<IfcFloat>( 1. )-d);

496 }

497

498 // --------------------------------------------------

499 size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {

500 ai_assert(InRange(a) && InRange(b));

501 return static_cast<size_t>( ceil(b) - floor(a) );

502 }

503

504 // --------------------------------------------------

505 ParamRange GetParametricRange() const {

506 return std::make_pair(static_cast<IfcFloat>( 0. ),static_cast<IfcFloat>(points.size()-1));

507 }

508

509 private:

510 const IfcPolyline& entity;

511 std::vector<IfcVector3> points;

512 };

513

514

515 } // anon

516

517

518 // ------------------------------------------------------------------------------------------------

519 Curve* Curve :: Convert(const IFC::IfcCurve& curve,ConversionData& conv)

520 {

521 if(curve.ToPtr<IfcBoundedCurve>()) {

522 if(const IfcPolyline* c = curve.ToPtr<IfcPolyline>()) {

523 return new PolyLine(*c,conv);

524 }

525 if(const IfcTrimmedCurve* c = curve.ToPtr<IfcTrimmedCurve>()) {

526 return new TrimmedCurve(*c,conv);

527 }

528 if(const IfcCompositeCurve* c = curve.ToPtr<IfcCompositeCurve>()) {

529 return new CompositeCurve(*c,conv);

530 }

531 //if(const IfcBSplineCurve* c = curve.ToPtr<IfcBSplineCurve>()) {

532 // return new BSplineCurve(*c,conv);

533 //}

534 }

535

536 if(curve.ToPtr<IfcConic>()) {

537 if(const IfcCircle* c = curve.ToPtr<IfcCircle>()) {

538 return new Circle(*c,conv);

539 }

540 if(const IfcEllipse* c = curve.ToPtr<IfcEllipse>()) {

541 return new Ellipse(*c,conv);

542 }

543 }

544

545 if(const IfcLine* c = curve.ToPtr<IfcLine>()) {

546 return new Line(*c,conv);

547 }

548

549 // XXX OffsetCurve2D, OffsetCurve3D not currently supported

550 return NULL;

551 }

552

553 #ifdef _DEBUG

554 // ------------------------------------------------------------------------------------------------

555 bool Curve :: InRange(IfcFloat u) const

556 {

557 const ParamRange range = GetParametricRange();

558 if (IsClosed()) {

559 return true;

560 //ai_assert(range.first != std::numeric_limits<IfcFloat>::infinity() && range.second != std::numeric_limits<IfcFloat>::infinity());

561 //u = range.first + fmod(u-range.first,range.second-range.first);

562 }

563 const IfcFloat epsilon = 1e-5;

564 return u - range.first > -epsilon && range.second - u > -epsilon;

565 }

566 #endif

567

568 // ------------------------------------------------------------------------------------------------

569 IfcFloat Curve :: GetParametricRangeDelta() const

570 {

571 const ParamRange& range = GetParametricRange();

572 return abs(range.second - range.first);

573 }

574

575 // ------------------------------------------------------------------------------------------------

576 size_t Curve :: EstimateSampleCount(IfcFloat a, IfcFloat b) const

577 {

578 ai_assert(InRange(a) && InRange(b));

579

580 // arbitrary default value, deriving classes should supply better suited values

581 return 16;

582 }

583

584 // ------------------------------------------------------------------------------------------------

585 IfcFloat RecursiveSearch(const Curve* cv, const IfcVector3& val, IfcFloat a, IfcFloat b, unsigned int samples, IfcFloat threshold, unsigned int recurse = 0, unsigned int max_recurse = 15)

586 {

587 ai_assert(samples>1);

588

589 const IfcFloat delta = (b-a)/samples, inf = std::numeric_limits<IfcFloat>::infinity();

590 IfcFloat min_point[2] = {a,b}, min_diff[2] = {inf,inf};

591 IfcFloat runner = a;

592

593 for (unsigned int i = 0; i < samples; ++i, runner += delta) {

594 const IfcFloat diff = (cv->Eval(runner)-val).SquareLength();

595 if (diff < min_diff[0]) {

596 min_diff[1] = min_diff[0];

597 min_point[1] = min_point[0];