diff options
Diffstat (limited to 'src/3rdparty/assimp/code/IFCOpenings.cpp')
| -rw-r--r-- | src/3rdparty/assimp/code/IFCOpenings.cpp | 1699 |
1 files changed, 0 insertions, 1699 deletions
diff --git a/src/3rdparty/assimp/code/IFCOpenings.cpp b/src/3rdparty/assimp/code/IFCOpenings.cpp deleted file mode 100644 index 4d57cd473..000000000 --- a/src/3rdparty/assimp/code/IFCOpenings.cpp +++ /dev/null @@ -1,1699 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2010, assimp team -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file IFCOpenings.cpp - * @brief Implements a subset of Ifc CSG operations for pouring - * holes for windows and doors into walls. - */ - - -#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER -#include "IFCUtil.h" -#include "PolyTools.h" -#include "ProcessHelper.h" - -#include "../contrib/poly2tri/poly2tri/poly2tri.h" -#include "../contrib/clipper/clipper.hpp" - -#include <iterator> - -namespace Assimp { - namespace IFC { - - using ClipperLib::ulong64; - // XXX use full -+ range ... - const ClipperLib::long64 max_ulong64 = 1518500249; // clipper.cpp / hiRange var - - //#define to_int64(p) (static_cast<ulong64>( std::max( 0., std::min( static_cast<IfcFloat>((p)), 1.) ) * max_ulong64 )) -#define to_int64(p) (static_cast<ulong64>(static_cast<IfcFloat>((p) ) * max_ulong64 )) -#define from_int64(p) (static_cast<IfcFloat>((p)) / max_ulong64) -#define one_vec (IfcVector2(static_cast<IfcFloat>(1.0),static_cast<IfcFloat>(1.0))) - - - // fallback method to generate wall openings - bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std::vector<IfcVector3>& nors, - TempMesh& curmesh); - - -typedef std::pair< IfcVector2, IfcVector2 > BoundingBox; -typedef std::map<IfcVector2,size_t,XYSorter> XYSortedField; - - -// ------------------------------------------------------------------------------------------------ -void QuadrifyPart(const IfcVector2& pmin, const IfcVector2& pmax, XYSortedField& field, - const std::vector< BoundingBox >& bbs, - std::vector<IfcVector2>& out) -{ - if (!(pmin.x-pmax.x) || !(pmin.y-pmax.y)) { - return; - } - - IfcFloat xs = 1e10, xe = 1e10; - bool found = false; - - // Search along the x-axis until we find an opening - XYSortedField::iterator start = field.begin(); - for(; start != field.end(); ++start) { - const BoundingBox& bb = bbs[(*start).second]; - if(bb.first.x >= pmax.x) { - break; - } - - if (bb.second.x > pmin.x && bb.second.y > pmin.y && bb.first.y < pmax.y) { - xs = bb.first.x; - xe = bb.second.x; - found = true; - break; - } - } - - if (!found) { - // the rectangle [pmin,pend] is opaque, fill it - out.push_back(pmin); - out.push_back(IfcVector2(pmin.x,pmax.y)); - out.push_back(pmax); - out.push_back(IfcVector2(pmax.x,pmin.y)); - return; - } - - xs = std::max(pmin.x,xs); - xe = std::min(pmax.x,xe); - - // see if there's an offset to fill at the top of our quad - if (xs - pmin.x) { - out.push_back(pmin); - out.push_back(IfcVector2(pmin.x,pmax.y)); - out.push_back(IfcVector2(xs,pmax.y)); - out.push_back(IfcVector2(xs,pmin.y)); - } - - // search along the y-axis for all openings that overlap xs and our quad - IfcFloat ylast = pmin.y; - found = false; - for(; start != field.end(); ++start) { - const BoundingBox& bb = bbs[(*start).second]; - if (bb.first.x > xs || bb.first.y >= pmax.y) { - break; - } - - if (bb.second.y > ylast) { - - found = true; - const IfcFloat ys = std::max(bb.first.y,pmin.y), ye = std::min(bb.second.y,pmax.y); - if (ys - ylast > 0.0f) { - QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,ys) ,field,bbs,out); - } - - // the following are the window vertices - - /*wnd.push_back(IfcVector2(xs,ys)); - wnd.push_back(IfcVector2(xs,ye)); - wnd.push_back(IfcVector2(xe,ye)); - wnd.push_back(IfcVector2(xe,ys));*/ - ylast = ye; - } - } - if (!found) { - // the rectangle [pmin,pend] is opaque, fill it - out.push_back(IfcVector2(xs,pmin.y)); - out.push_back(IfcVector2(xs,pmax.y)); - out.push_back(IfcVector2(xe,pmax.y)); - out.push_back(IfcVector2(xe,pmin.y)); - return; - } - if (ylast < pmax.y) { - QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,pmax.y) ,field,bbs,out); - } - - // now for the whole rest - if (pmax.x-xe) { - QuadrifyPart(IfcVector2(xe,pmin.y), pmax ,field,bbs,out); - } -} - -typedef std::vector<IfcVector2> Contour; -typedef std::vector<bool> SkipList; // should probably use int for performance reasons - -struct ProjectedWindowContour -{ - Contour contour; - BoundingBox bb; - SkipList skiplist; - bool is_rectangular; - - - ProjectedWindowContour(const Contour& contour, const BoundingBox& bb, bool is_rectangular) - : contour(contour) - , bb(bb) - , is_rectangular(is_rectangular) - {} - - - bool IsInvalid() const { - return contour.empty(); - } - - void FlagInvalid() { - contour.clear(); - } - - void PrepareSkiplist() { - skiplist.resize(contour.size(),false); - } -}; - -typedef std::vector< ProjectedWindowContour > ContourVector; - -// ------------------------------------------------------------------------------------------------ -bool BoundingBoxesOverlapping( const BoundingBox &ibb, const BoundingBox &bb ) -{ - // count the '=' case as non-overlapping but as adjacent to each other - return ibb.first.x < bb.second.x && ibb.second.x > bb.first.x && - ibb.first.y < bb.second.y && ibb.second.y > bb.first.y; -} - -// ------------------------------------------------------------------------------------------------ -bool IsDuplicateVertex(const IfcVector2& vv, const std::vector<IfcVector2>& temp_contour) -{ - // sanity check for duplicate vertices - for(const IfcVector2& cp : temp_contour) { - if ((cp-vv).SquareLength() < 1e-5f) { - return true; - } - } - return false; -} - -// ------------------------------------------------------------------------------------------------ -void ExtractVerticesFromClipper(const ClipperLib::Polygon& poly, std::vector<IfcVector2>& temp_contour, - bool filter_duplicates = false) -{ - temp_contour.clear(); - for(const ClipperLib::IntPoint& point : poly) { - IfcVector2 vv = IfcVector2( from_int64(point.X), from_int64(point.Y)); - vv = std::max(vv,IfcVector2()); - vv = std::min(vv,one_vec); - - if (!filter_duplicates || !IsDuplicateVertex(vv, temp_contour)) { - temp_contour.push_back(vv); - } - } -} - -// ------------------------------------------------------------------------------------------------ -BoundingBox GetBoundingBox(const ClipperLib::Polygon& poly) -{ - IfcVector2 newbb_min, newbb_max; - MinMaxChooser<IfcVector2>()(newbb_min, newbb_max); - - for(const ClipperLib::IntPoint& point : poly) { - IfcVector2 vv = IfcVector2( from_int64(point.X), from_int64(point.Y)); - - // sanity rounding - vv = std::max(vv,IfcVector2()); - vv = std::min(vv,one_vec); - - newbb_min = std::min(newbb_min,vv); - newbb_max = std::max(newbb_max,vv); - } - return BoundingBox(newbb_min, newbb_max); -} - -// ------------------------------------------------------------------------------------------------ -void InsertWindowContours(const ContourVector& contours, - const std::vector<TempOpening>& /*openings*/, - TempMesh& curmesh) -{ - // fix windows - we need to insert the real, polygonal shapes into the quadratic holes that we have now - for(size_t i = 0; i < contours.size();++i) { - const BoundingBox& bb = contours[i].bb; - const std::vector<IfcVector2>& contour = contours[i].contour; - if(contour.empty()) { - continue; - } - - // check if we need to do it at all - many windows just fit perfectly into their quadratic holes, - // i.e. their contours *are* already their bounding boxes. - if (contour.size() == 4) { - std::set<IfcVector2,XYSorter> verts; - for(size_t n = 0; n < 4; ++n) { - verts.insert(contour[n]); - } - const std::set<IfcVector2,XYSorter>::const_iterator end = verts.end(); - if (verts.find(bb.first)!=end && verts.find(bb.second)!=end - && verts.find(IfcVector2(bb.first.x,bb.second.y))!=end - && verts.find(IfcVector2(bb.second.x,bb.first.y))!=end - ) { - continue; - } - } - - const IfcFloat diag = (bb.first-bb.second).Length(); - const IfcFloat epsilon = diag/1000.f; - - // walk through all contour points and find those that lie on the BB corner - size_t last_hit = -1, very_first_hit = -1; - IfcVector2 edge; - for(size_t n = 0, e=0, size = contour.size();; n=(n+1)%size, ++e) { - - // sanity checking - if (e == size*2) { - IFCImporter::LogError("encountered unexpected topology while generating window contour"); - break; - } - - const IfcVector2& v = contour[n]; - - bool hit = false; - if (std::fabs(v.x-bb.first.x)<epsilon) { - edge.x = bb.first.x; - hit = true; - } - else if (std::fabs(v.x-bb.second.x)<epsilon) { - edge.x = bb.second.x; - hit = true; - } - - if (std::fabs(v.y-bb.first.y)<epsilon) { - edge.y = bb.first.y; - hit = true; - } - else if (std::fabs(v.y-bb.second.y)<epsilon) { - edge.y = bb.second.y; - hit = true; - } - - if (hit) { - if (last_hit != (size_t)-1) { - - const size_t old = curmesh.verts.size(); - size_t cnt = last_hit > n ? size-(last_hit-n) : n-last_hit; - for(size_t a = last_hit, e = 0; e <= cnt; a=(a+1)%size, ++e) { - // hack: this is to fix cases where opening contours are self-intersecting. - // Clipper doesn't produce such polygons, but as soon as we're back in - // our brave new floating-point world, very small distances are consumed - // by the maximum available precision, leading to self-intersecting - // polygons. This fix makes concave windows fail even worse, but - // anyway, fail is fail. - if ((contour[a] - edge).SquareLength() > diag*diag*0.7) { - continue; - } - curmesh.verts.push_back(IfcVector3(contour[a].x, contour[a].y, 0.0f)); - } - - if (edge != contour[last_hit]) { - - IfcVector2 corner = edge; - - if (std::fabs(contour[last_hit].x-bb.first.x)<epsilon) { - corner.x = bb.first.x; - } - else if (std::fabs(contour[last_hit].x-bb.second.x)<epsilon) { - corner.x = bb.second.x; - } - - if (std::fabs(contour[last_hit].y-bb.first.y)<epsilon) { - corner.y = bb.first.y; - } - else if (std::fabs(contour[last_hit].y-bb.second.y)<epsilon) { - corner.y = bb.second.y; - } - - curmesh.verts.push_back(IfcVector3(corner.x, corner.y, 0.0f)); - } - else if (cnt == 1) { - // avoid degenerate polygons (also known as lines or points) - curmesh.verts.erase(curmesh.verts.begin()+old,curmesh.verts.end()); - } - - if (const size_t d = curmesh.verts.size()-old) { - curmesh.vertcnt.push_back(static_cast<unsigned int>(d)); - std::reverse(curmesh.verts.rbegin(),curmesh.verts.rbegin()+d); - } - if (n == very_first_hit) { - break; - } - } - else { - very_first_hit = n; - } - - last_hit = n; - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -void MergeWindowContours (const std::vector<IfcVector2>& a, - const std::vector<IfcVector2>& b, - ClipperLib::ExPolygons& out) -{ - out.clear(); - - ClipperLib::Clipper clipper; - ClipperLib::Polygon clip; - - for(const IfcVector2& pip : a) { - clip.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - } - - if (ClipperLib::Orientation(clip)) { - std::reverse(clip.begin(), clip.end()); - } - - clipper.AddPolygon(clip, ClipperLib::ptSubject); - clip.clear(); - - for(const IfcVector2& pip : b) { - clip.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - } - - if (ClipperLib::Orientation(clip)) { - std::reverse(clip.begin(), clip.end()); - } - - clipper.AddPolygon(clip, ClipperLib::ptSubject); - clipper.Execute(ClipperLib::ctUnion, out,ClipperLib::pftNonZero,ClipperLib::pftNonZero); -} - -// ------------------------------------------------------------------------------------------------ -// Subtract a from b -void MakeDisjunctWindowContours (const std::vector<IfcVector2>& a, - const std::vector<IfcVector2>& b, - ClipperLib::ExPolygons& out) -{ - out.clear(); - - ClipperLib::Clipper clipper; - ClipperLib::Polygon clip; - - for(const IfcVector2& pip : a) { - clip.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - } - - if (ClipperLib::Orientation(clip)) { - std::reverse(clip.begin(), clip.end()); - } - - clipper.AddPolygon(clip, ClipperLib::ptClip); - clip.clear(); - - for(const IfcVector2& pip : b) { - clip.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - } - - if (ClipperLib::Orientation(clip)) { - std::reverse(clip.begin(), clip.end()); - } - - clipper.AddPolygon(clip, ClipperLib::ptSubject); - clipper.Execute(ClipperLib::ctDifference, out,ClipperLib::pftNonZero,ClipperLib::pftNonZero); -} - -// ------------------------------------------------------------------------------------------------ -void CleanupWindowContour(ProjectedWindowContour& window) -{ - std::vector<IfcVector2> scratch; - std::vector<IfcVector2>& contour = window.contour; - - ClipperLib::Polygon subject; - ClipperLib::Clipper clipper; - ClipperLib::ExPolygons clipped; - - for(const IfcVector2& pip : contour) { - subject.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - } - - clipper.AddPolygon(subject,ClipperLib::ptSubject); - clipper.Execute(ClipperLib::ctUnion,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero); - - // This should yield only one polygon or something went wrong - if (clipped.size() != 1) { - - // Empty polygon? drop the contour altogether - if(clipped.empty()) { - IFCImporter::LogError("error during polygon clipping, window contour is degenerate"); - window.FlagInvalid(); - return; - } - - // Else: take the first only - IFCImporter::LogError("error during polygon clipping, window contour is not convex"); - } - - ExtractVerticesFromClipper(clipped[0].outer, scratch); - // Assume the bounding box doesn't change during this operation -} - -// ------------------------------------------------------------------------------------------------ -void CleanupWindowContours(ContourVector& contours) -{ - // Use PolyClipper to clean up window contours - try { - for(ProjectedWindowContour& window : contours) { - CleanupWindowContour(window); - } - } - catch (const char* sx) { - IFCImporter::LogError("error during polygon clipping, window shape may be wrong: (Clipper: " - + std::string(sx) + ")"); - } -} - -// ------------------------------------------------------------------------------------------------ -void CleanupOuterContour(const std::vector<IfcVector2>& contour_flat, TempMesh& curmesh) -{ - std::vector<IfcVector3> vold; - std::vector<unsigned int> iold; - - vold.reserve(curmesh.verts.size()); - iold.reserve(curmesh.vertcnt.size()); - - // Fix the outer contour using polyclipper - try { - - ClipperLib::Polygon subject; - ClipperLib::Clipper clipper; - ClipperLib::ExPolygons clipped; - - ClipperLib::Polygon clip; - clip.reserve(contour_flat.size()); - for(const IfcVector2& pip : contour_flat) { - clip.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - } - - if (!ClipperLib::Orientation(clip)) { - std::reverse(clip.begin(), clip.end()); - } - - // We need to run polyclipper on every single polygon -- we can't run it one all - // of them at once or it would merge them all together which would undo all - // previous steps - subject.reserve(4); - size_t index = 0; - size_t countdown = 0; - for(const IfcVector3& pip : curmesh.verts) { - if (!countdown) { - countdown = curmesh.vertcnt[index++]; - if (!countdown) { - continue; - } - } - subject.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - if (--countdown == 0) { - if (!ClipperLib::Orientation(subject)) { - std::reverse(subject.begin(), subject.end()); - } - - clipper.AddPolygon(subject,ClipperLib::ptSubject); - clipper.AddPolygon(clip,ClipperLib::ptClip); - - clipper.Execute(ClipperLib::ctIntersection,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero); - - for(const ClipperLib::ExPolygon& ex : clipped) { - iold.push_back(static_cast<unsigned int>(ex.outer.size())); - for(const ClipperLib::IntPoint& point : ex.outer) { - vold.push_back(IfcVector3( - from_int64(point.X), - from_int64(point.Y), - 0.0f)); - } - } - - subject.clear(); - clipped.clear(); - clipper.Clear(); - } - } - } - catch (const char* sx) { - IFCImporter::LogError("Ifc: error during polygon clipping, wall contour line may be wrong: (Clipper: " - + std::string(sx) + ")"); - - return; - } - - // swap data arrays - std::swap(vold,curmesh.verts); - std::swap(iold,curmesh.vertcnt); -} - -typedef std::vector<TempOpening*> OpeningRefs; -typedef std::vector<OpeningRefs > OpeningRefVector; - -typedef std::vector<std::pair< - ContourVector::const_iterator, - Contour::const_iterator> -> ContourRefVector; - -// ------------------------------------------------------------------------------------------------ -bool BoundingBoxesAdjacent(const BoundingBox& bb, const BoundingBox& ibb) -{ - // TODO: I'm pretty sure there is a much more compact way to check this - const IfcFloat epsilon = 1e-5f; - return (std::fabs(bb.second.x - ibb.first.x) < epsilon && bb.first.y <= ibb.second.y && bb.second.y >= ibb.first.y) || - (std::fabs(bb.first.x - ibb.second.x) < epsilon && ibb.first.y <= bb.second.y && ibb.second.y >= bb.first.y) || - (std::fabs(bb.second.y - ibb.first.y) < epsilon && bb.first.x <= ibb.second.x && bb.second.x >= ibb.first.x) || - (std::fabs(bb.first.y - ibb.second.y) < epsilon && ibb.first.x <= bb.second.x && ibb.second.x >= bb.first.x); -} - -// ------------------------------------------------------------------------------------------------ -// Check if m0,m1 intersects n0,n1 assuming same ordering of the points in the line segments -// output the intersection points on n0,n1 -bool IntersectingLineSegments(const IfcVector2& n0, const IfcVector2& n1, - const IfcVector2& m0, const IfcVector2& m1, - IfcVector2& out0, IfcVector2& out1) -{ - const IfcVector2 n0_to_n1 = n1 - n0; - - const IfcVector2 n0_to_m0 = m0 - n0; - const IfcVector2 n1_to_m1 = m1 - n1; - - const IfcVector2 n0_to_m1 = m1 - n0; - - const IfcFloat e = 1e-5f; - const IfcFloat smalle = 1e-9f; - - static const IfcFloat inf = std::numeric_limits<IfcFloat>::infinity(); - - if (!(n0_to_m0.SquareLength() < e*e || std::fabs(n0_to_m0 * n0_to_n1) / (n0_to_m0.Length() * n0_to_n1.Length()) > 1-1e-5 )) { - return false; - } - - if (!(n1_to_m1.SquareLength() < e*e || std::fabs(n1_to_m1 * n0_to_n1) / (n1_to_m1.Length() * n0_to_n1.Length()) > 1-1e-5 )) { - return false; - } - - IfcFloat s0; - IfcFloat s1; - - // pick the axis with the higher absolute difference so the result - // is more accurate. Since we cannot guarantee that the axis with - // the higher absolute difference is big enough as to avoid - // divisions by zero, the case 0/0 ~ infinity is detected and - // handled separately. - if(std::fabs(n0_to_n1.x) > std::fabs(n0_to_n1.y)) { - s0 = n0_to_m0.x / n0_to_n1.x; - s1 = n0_to_m1.x / n0_to_n1.x; - - if (std::fabs(s0) == inf && std::fabs(n0_to_m0.x) < smalle) { - s0 = 0.; - } - if (std::fabs(s1) == inf && std::fabs(n0_to_m1.x) < smalle) { - s1 = 0.; - } - } - else { - s0 = n0_to_m0.y / n0_to_n1.y; - s1 = n0_to_m1.y / n0_to_n1.y; - - if (std::fabs(s0) == inf && std::fabs(n0_to_m0.y) < smalle) { - s0 = 0.; - } - if (std::fabs(s1) == inf && std::fabs(n0_to_m1.y) < smalle) { - s1 = 0.; - } - } - - if (s1 < s0) { - std::swap(s1,s0); - } - - s0 = std::max(0.0,s0); - s1 = std::max(0.0,s1); - - s0 = std::min(1.0,s0); - s1 = std::min(1.0,s1); - - if (std::fabs(s1-s0) < e) { - return false; - } - - out0 = n0 + s0 * n0_to_n1; - out1 = n0 + s1 * n0_to_n1; - - return true; -} - -// ------------------------------------------------------------------------------------------------ -void FindAdjacentContours(ContourVector::iterator current, const ContourVector& contours) -{ - const IfcFloat sqlen_epsilon = static_cast<IfcFloat>(1e-8); - const BoundingBox& bb = (*current).bb; - - // What is to be done here is to populate the skip lists for the contour - // and to add necessary padding points when needed. - SkipList& skiplist = (*current).skiplist; - - // First step to find possible adjacent contours is to check for adjacent bounding - // boxes. If the bounding boxes are not adjacent, the contours lines cannot possibly be. - for (ContourVector::const_iterator it = contours.begin(), end = contours.end(); it != end; ++it) { - if ((*it).IsInvalid()) { - continue; - } - - // this left here to make clear we also run on the current contour - // to check for overlapping contour segments (which can happen due - // to projection artifacts). - //if(it == current) { - // continue; - //} - - const bool is_me = it == current; - - const BoundingBox& ibb = (*it).bb; - - // Assumption: the bounding boxes are pairwise disjoint or identical - ai_assert(is_me || !BoundingBoxesOverlapping(bb, ibb)); - - if (is_me || BoundingBoxesAdjacent(bb, ibb)) { - - // Now do a each-against-everyone check for intersecting contour - // lines. This obviously scales terribly, but in typical real - // world Ifc files it will not matter since most windows that - // are adjacent to each others are rectangular anyway. - - Contour& ncontour = (*current).contour; - const Contour& mcontour = (*it).contour; - - for (size_t n = 0; n < ncontour.size(); ++n) { - const IfcVector2 n0 = ncontour[n]; - const IfcVector2 n1 = ncontour[(n+1) % ncontour.size()]; - - for (size_t m = 0, mend = (is_me ? n : mcontour.size()); m < mend; ++m) { - ai_assert(&mcontour != &ncontour || m < n); - - const IfcVector2 m0 = mcontour[m]; - const IfcVector2 m1 = mcontour[(m+1) % mcontour.size()]; - - IfcVector2 isect0, isect1; - if (IntersectingLineSegments(n0,n1, m0, m1, isect0, isect1)) { - - if ((isect0 - n0).SquareLength() > sqlen_epsilon) { - ++n; - - ncontour.insert(ncontour.begin() + n, isect0); - skiplist.insert(skiplist.begin() + n, true); - } - else { - skiplist[n] = true; - } - - if ((isect1 - n1).SquareLength() > sqlen_epsilon) { - ++n; - - ncontour.insert(ncontour.begin() + n, isect1); - skiplist.insert(skiplist.begin() + n, false); - } - } - } - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE bool LikelyBorder(const IfcVector2& vdelta) -{ - const IfcFloat dot_point_epsilon = static_cast<IfcFloat>(1e-5); - return std::fabs(vdelta.x * vdelta.y) < dot_point_epsilon; -} - -// ------------------------------------------------------------------------------------------------ -void FindBorderContours(ContourVector::iterator current) -{ - const IfcFloat border_epsilon_upper = static_cast<IfcFloat>(1-1e-4); - const IfcFloat border_epsilon_lower = static_cast<IfcFloat>(1e-4); - - bool outer_border = false; - bool start_on_outer_border = false; - - SkipList& skiplist = (*current).skiplist; - IfcVector2 last_proj_point; - - const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end(); - - for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) { - const IfcVector2& proj_point = *cit; - - // Check if this connection is along the outer boundary of the projection - // plane. In such a case we better drop it because such 'edges' should - // not have any geometry to close them (think of door openings). - if (proj_point.x <= border_epsilon_lower || proj_point.x >= border_epsilon_upper || - proj_point.y <= border_epsilon_lower || proj_point.y >= border_epsilon_upper) { - - if (outer_border) { - ai_assert(cit != cbegin); - if (LikelyBorder(proj_point - last_proj_point)) { - skiplist[std::distance(cbegin, cit) - 1] = true; - } - } - else if (cit == cbegin) { - start_on_outer_border = true; - } - - outer_border = true; - } - else { - outer_border = false; - } - - last_proj_point = proj_point; - } - - // handle last segment - if (outer_border && start_on_outer_border) { - const IfcVector2& proj_point = *cbegin; - if (LikelyBorder(proj_point - last_proj_point)) { - skiplist[skiplist.size()-1] = true; - } - } -} - -// ------------------------------------------------------------------------------------------------ -AI_FORCE_INLINE bool LikelyDiagonal(IfcVector2 vdelta) -{ - vdelta.x = std::fabs(vdelta.x); - vdelta.y = std::fabs(vdelta.y); - return (std::fabs(vdelta.x-vdelta.y) < 0.8 * std::max(vdelta.x, vdelta.y)); -} - -// ------------------------------------------------------------------------------------------------ -void FindLikelyCrossingLines(ContourVector::iterator current) -{ - SkipList& skiplist = (*current).skiplist; - IfcVector2 last_proj_point; - - const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end(); - for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) { - const IfcVector2& proj_point = *cit; - - if (cit != cbegin) { - IfcVector2 vdelta = proj_point - last_proj_point; - if (LikelyDiagonal(vdelta)) { - skiplist[std::distance(cbegin, cit) - 1] = true; - } - } - - last_proj_point = proj_point; - } - - // handle last segment - if (LikelyDiagonal(*cbegin - last_proj_point)) { - skiplist[skiplist.size()-1] = true; - } -} - -// ------------------------------------------------------------------------------------------------ -size_t CloseWindows(ContourVector& contours, - const IfcMatrix4& minv, - OpeningRefVector& contours_to_openings, - TempMesh& curmesh) -{ - size_t closed = 0; - // For all contour points, check if one of the assigned openings does - // already have points assigned to it. In this case, assume this is - // the other side of the wall and generate connections between - // the two holes in order to close the window. - - // All this gets complicated by the fact that contours may pertain to - // multiple openings(due to merging of adjacent or overlapping openings). - // The code is based on the assumption that this happens symmetrically - // on both sides of the wall. If it doesn't (which would be a bug anyway) - // wrong geometry may be generated. - for (ContourVector::iterator it = contours.begin(), end = contours.end(); it != end; ++it) { - if ((*it).IsInvalid()) { - continue; - } - OpeningRefs& refs = contours_to_openings[std::distance(contours.begin(), it)]; - - bool has_other_side = false; - for(const TempOpening* opening : refs) { - if(!opening->wallPoints.empty()) { - has_other_side = true; - break; - } - } - - if (has_other_side) { - - ContourRefVector adjacent_contours; - - // prepare a skiplist for this contour. The skiplist is used to - // eliminate unwanted contour lines for adjacent windows and - // those bordering the outer frame. - (*it).PrepareSkiplist(); - - FindAdjacentContours(it, contours); - FindBorderContours(it); - - // if the window is the result of a finite union or intersection of rectangles, - // there shouldn't be any crossing or diagonal lines in it. Such lines would - // be artifacts caused by numerical inaccuracies or other bugs in polyclipper - // and our own code. Since rectangular openings are by far the most frequent - // case, it is worth filtering for this corner case. - if((*it).is_rectangular) { - FindLikelyCrossingLines(it); - } - - ai_assert((*it).skiplist.size() == (*it).contour.size()); - - SkipList::const_iterator skipbegin = (*it).skiplist.begin(); - - curmesh.verts.reserve(curmesh.verts.size() + (*it).contour.size() * 4); - curmesh.vertcnt.reserve(curmesh.vertcnt.size() + (*it).contour.size()); - - bool reverseCountourFaces = false; - - // compare base poly normal and contour normal to detect if we need to reverse the face winding - if(curmesh.vertcnt.size() > 0) { - IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.verts.data(), curmesh.vertcnt.front()); - - std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size()); - - for(size_t a = 0; a < it->contour.size(); ++a) - worldSpaceContourVtx[a] = minv * IfcVector3(it->contour[a].x, it->contour[a].y, 0.0); - - IfcVector3 contourNormal = TempMesh::ComputePolygonNormal(worldSpaceContourVtx.data(), worldSpaceContourVtx.size()); - - reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0; - } - - // XXX this algorithm is really a bit inefficient - both in terms - // of constant factor and of asymptotic runtime. - std::vector<bool>::const_iterator skipit = skipbegin; - - IfcVector3 start0; - IfcVector3 start1; - - const Contour::const_iterator cbegin = (*it).contour.begin(), cend = (*it).contour.end(); - - bool drop_this_edge = false; - for (Contour::const_iterator cit = cbegin; cit != cend; ++cit, drop_this_edge = *skipit++) { - const IfcVector2& proj_point = *cit; - - // Locate the closest opposite point. This should be a good heuristic to - // connect only the points that are really intended to be connected. - IfcFloat best = static_cast<IfcFloat>(1e10); - IfcVector3 bestv; - - const IfcVector3 world_point = minv * IfcVector3(proj_point.x,proj_point.y,0.0f); - - for(const TempOpening* opening : refs) { - for(const IfcVector3& other : opening->wallPoints) { - const IfcFloat sqdist = (world_point - other).SquareLength(); - - if (sqdist < best) { - // avoid self-connections - if(sqdist < 1e-5) { - continue; - } - - bestv = other; - best = sqdist; - } - } - } - - if (drop_this_edge) { - curmesh.verts.pop_back(); - curmesh.verts.pop_back(); - } - else { - curmesh.verts.push_back(((cit == cbegin) != reverseCountourFaces) ? world_point : bestv); - curmesh.verts.push_back(((cit == cbegin) != reverseCountourFaces) ? bestv : world_point); - - curmesh.vertcnt.push_back(4); - ++closed; - } - - if (cit == cbegin) { - start0 = world_point; - start1 = bestv; - continue; - } - - curmesh.verts.push_back(reverseCountourFaces ? bestv : world_point); - curmesh.verts.push_back(reverseCountourFaces ? world_point : bestv); - - if (cit == cend - 1) { - drop_this_edge = *skipit; - - // Check if the final connection (last to first element) is itself - // a border edge that needs to be dropped. - if (drop_this_edge) { - --closed; - curmesh.vertcnt.pop_back(); - curmesh.verts.pop_back(); - curmesh.verts.pop_back(); - } - else { - curmesh.verts.push_back(reverseCountourFaces ? start0 : start1); - curmesh.verts.push_back(reverseCountourFaces ? start1 : start0); - } - } - } - } - else { - - const Contour::const_iterator cbegin = (*it).contour.begin(), cend = (*it).contour.end(); - for(TempOpening* opening : refs) { - ai_assert(opening->wallPoints.empty()); - opening->wallPoints.reserve(opening->wallPoints.capacity() + (*it).contour.size()); - for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) { - - const IfcVector2& proj_point = *cit; - opening->wallPoints.push_back(minv * IfcVector3(proj_point.x,proj_point.y,0.0f)); - } - } - } - } - return closed; -} - -// ------------------------------------------------------------------------------------------------ -void Quadrify(const std::vector< BoundingBox >& bbs, TempMesh& curmesh) -{ - ai_assert(curmesh.IsEmpty()); - - std::vector<IfcVector2> quads; - quads.reserve(bbs.size()*4); - - // sort openings by x and y axis as a preliminiary to the QuadrifyPart() algorithm - XYSortedField field; - for (std::vector<BoundingBox>::const_iterator it = bbs.begin(); it != bbs.end(); ++it) { - if (field.find((*it).first) != field.end()) { - IFCImporter::LogWarn("constraint failure during generation of wall openings, results may be faulty"); - } - field[(*it).first] = std::distance(bbs.begin(),it); - } - - QuadrifyPart(IfcVector2(),one_vec,field,bbs,quads); - ai_assert(!(quads.size() % 4)); - - curmesh.vertcnt.resize(quads.size()/4,4); - curmesh.verts.reserve(quads.size()); - for(const IfcVector2& v2 : quads) { - curmesh.verts.push_back(IfcVector3(v2.x, v2.y, static_cast<IfcFloat>(0.0))); - } -} - -// ------------------------------------------------------------------------------------------------ -void Quadrify(const ContourVector& contours, TempMesh& curmesh) -{ - std::vector<BoundingBox> bbs; - bbs.reserve(contours.size()); - - for(const ContourVector::value_type& val : contours) { - bbs.push_back(val.bb); - } - - Quadrify(bbs, curmesh); -} - -// ------------------------------------------------------------------------------------------------ -IfcMatrix4 ProjectOntoPlane(std::vector<IfcVector2>& out_contour, const TempMesh& in_mesh, - bool &ok, IfcVector3& nor_out) -{ - const std::vector<IfcVector3>& in_verts = in_mesh.verts; - ok = true; - - IfcMatrix4 m = IfcMatrix4(DerivePlaneCoordinateSpace(in_mesh, ok, nor_out)); - if(!ok) { - return IfcMatrix4(); - } -#ifdef ASSIMP_BUILD_DEBUG - const IfcFloat det = m.Determinant(); - ai_assert(std::fabs(det-1) < 1e-5); -#endif - - IfcFloat zcoord = 0; - out_contour.reserve(in_verts.size()); - - - IfcVector3 vmin, vmax; - MinMaxChooser<IfcVector3>()(vmin, vmax); - - // Project all points into the new coordinate system, collect min/max verts on the way - for(const IfcVector3& x : in_verts) { - const IfcVector3 vv = m * x; - // keep Z offset in the plane coordinate system. Ignoring precision issues - // (which are present, of course), this should be the same value for - // all polygon vertices (assuming the polygon is planar). - - // XXX this should be guarded, but we somehow need to pick a suitable - // epsilon - // if(coord != -1.0f) { - // assert(std::fabs(coord - vv.z) < 1e-3f); - // } - zcoord += vv.z; - vmin = std::min(vv, vmin); - vmax = std::max(vv, vmax); - - out_contour.push_back(IfcVector2(vv.x,vv.y)); - } - - zcoord /= in_verts.size(); - - // Further improve the projection by mapping the entire working set into - // [0,1] range. This gives us a consistent data range so all epsilons - // used below can be constants. - vmax -= vmin; - for(IfcVector2& vv : out_contour) { - vv.x = (vv.x - vmin.x) / vmax.x; - vv.y = (vv.y - vmin.y) / vmax.y; - - // sanity rounding - vv = std::max(vv,IfcVector2()); - vv = std::min(vv,one_vec); - } - - IfcMatrix4 mult; - mult.a1 = static_cast<IfcFloat>(1.0) / vmax.x; - mult.b2 = static_cast<IfcFloat>(1.0) / vmax.y; - - mult.a4 = -vmin.x * mult.a1; - mult.b4 = -vmin.y * mult.b2; - mult.c4 = -zcoord; - m = mult * m; - - // debug code to verify correctness -#ifdef ASSIMP_BUILD_DEBUG - std::vector<IfcVector2> out_contour2; - for(const IfcVector3& x : in_verts) { - const IfcVector3& vv = m * x; - - out_contour2.push_back(IfcVector2(vv.x,vv.y)); - ai_assert(std::fabs(vv.z) < vmax.z + 1e-8); - } - - for(size_t i = 0; i < out_contour.size(); ++i) { - ai_assert((out_contour[i]-out_contour2[i]).SquareLength() < 1e-6); - } -#endif - - return m; -} - -// ------------------------------------------------------------------------------------------------ -bool GenerateOpenings(std::vector<TempOpening>& openings, - const std::vector<IfcVector3>& nors, - TempMesh& curmesh, - bool check_intersection, - bool generate_connection_geometry, - const IfcVector3& wall_extrusion_axis) -{ - OpeningRefVector contours_to_openings; - - // Try to derive a solid base plane within the current surface for use as - // working coordinate system. Map all vertices onto this plane and - // rescale them to [0,1] range. This normalization means all further - // epsilons need not be scaled. - bool ok = true; - - std::vector<IfcVector2> contour_flat; - - IfcVector3 nor; - const IfcMatrix4 m = ProjectOntoPlane(contour_flat, curmesh, ok, nor); - if(!ok) { - return false; - } - - // Obtain inverse transform for getting back to world space later on - const IfcMatrix4 minv = IfcMatrix4(m).Inverse(); - - // Compute bounding boxes for all 2D openings in projection space - ContourVector contours; - - std::vector<IfcVector2> temp_contour; - std::vector<IfcVector2> temp_contour2; - - IfcVector3 wall_extrusion_axis_norm = wall_extrusion_axis; - wall_extrusion_axis_norm.Normalize(); - - for(TempOpening& opening :openings) { - - // extrusionDir may be 0,0,0 on case where the opening mesh is not an - // IfcExtrudedAreaSolid but something else (i.e. a brep) - IfcVector3 norm_extrusion_dir = opening.extrusionDir; - if (norm_extrusion_dir.SquareLength() > 1e-10) { - norm_extrusion_dir.Normalize(); - } - else { - norm_extrusion_dir = IfcVector3(); - } - - TempMesh* profile_data = opening.profileMesh.get(); - bool is_2d_source = false; - if (opening.profileMesh2D && norm_extrusion_dir.SquareLength() > 0) { - - if(std::fabs(norm_extrusion_dir * wall_extrusion_axis_norm) < 0.1) { - // horizontal extrusion - if (std::fabs(norm_extrusion_dir * nor) > 0.9) { - profile_data = opening.profileMesh2D.get(); - is_2d_source = true; - } - } - else { - // vertical extrusion - if (std::fabs(norm_extrusion_dir * nor) > 0.9) { - profile_data = opening.profileMesh2D.get(); - is_2d_source = true; - } - } - } - std::vector<IfcVector3> profile_verts = profile_data->verts; - std::vector<unsigned int> profile_vertcnts = profile_data->vertcnt; - if(profile_verts.size() <= 2) { - continue; - } - - // The opening meshes are real 3D meshes so skip over all faces - // clearly facing into the wrong direction. Also, we need to check - // whether the meshes do actually intersect the base surface plane. - // This is done by recording minimum and maximum values for the - // d component of the plane equation for all polys and checking - // against surface d. - - // Use the sign of the dot product of the face normal to the plane - // normal to determine to which side of the difference mesh a - // triangle belongs. Get independent bounding boxes and vertex - // sets for both sides and take the better one (we can't just - // take both - this would likely cause major screwup of vertex - // winding, producing errors as late as in CloseWindows()). - IfcFloat dmin, dmax; - MinMaxChooser<IfcFloat>()(dmin,dmax); - - temp_contour.clear(); - temp_contour2.clear(); - - IfcVector2 vpmin,vpmax; - MinMaxChooser<IfcVector2>()(vpmin,vpmax); - - IfcVector2 vpmin2,vpmax2; - MinMaxChooser<IfcVector2>()(vpmin2,vpmax2); - - for (size_t f = 0, vi_total = 0, fend = profile_vertcnts.size(); f < fend; ++f) { - - bool side_flag = true; - if (!is_2d_source) { - const IfcVector3 face_nor = ((profile_verts[vi_total+2] - profile_verts[vi_total]) ^ - (profile_verts[vi_total+1] - profile_verts[vi_total])).Normalize(); - - const IfcFloat abs_dot_face_nor = std::abs(nor * face_nor); - if (abs_dot_face_nor < 0.9) { - vi_total += profile_vertcnts[f]; - continue; - } - - side_flag = nor * face_nor > 0; - } - - for (unsigned int vi = 0, vend = profile_vertcnts[f]; vi < vend; ++vi, ++vi_total) { - const IfcVector3& x = profile_verts[vi_total]; - - const IfcVector3 v = m * x; - IfcVector2 vv(v.x, v.y); - - //if(check_intersection) { - dmin = std::min(dmin, v.z); - dmax = std::max(dmax, v.z); - //} - - // sanity rounding - vv = std::max(vv,IfcVector2()); - vv = std::min(vv,one_vec); - - if(side_flag) { - vpmin = std::min(vpmin,vv); - vpmax = std::max(vpmax,vv); - } - else { - vpmin2 = std::min(vpmin2,vv); - vpmax2 = std::max(vpmax2,vv); - } - - std::vector<IfcVector2>& store = side_flag ? temp_contour : temp_contour2; - - if (!IsDuplicateVertex(vv, store)) { - store.push_back(vv); - } - } - } - - if (temp_contour2.size() > 2) { - ai_assert(!is_2d_source); - const IfcVector2 area = vpmax-vpmin; - const IfcVector2 area2 = vpmax2-vpmin2; - if (temp_contour.size() <= 2 || std::fabs(area2.x * area2.y) > std::fabs(area.x * area.y)) { - temp_contour.swap(temp_contour2); - - vpmax = vpmax2; - vpmin = vpmin2; - } - } - if(temp_contour.size() <= 2) { - continue; - } - - // TODO: This epsilon may be too large - const IfcFloat epsilon = std::fabs(dmax-dmin) * 0.0001; - if (!is_2d_source && check_intersection && (0 < dmin-epsilon || 0 > dmax+epsilon)) { - continue; - } - - BoundingBox bb = BoundingBox(vpmin,vpmax); - - // Skip over very small openings - these are likely projection errors - // (i.e. they don't belong to this side of the wall) - if(std::fabs(vpmax.x - vpmin.x) * std::fabs(vpmax.y - vpmin.y) < static_cast<IfcFloat>(1e-10)) { - continue; - } - std::vector<TempOpening*> joined_openings(1, &opening); - - bool is_rectangle = temp_contour.size() == 4; - - // See if this BB intersects or is in close adjacency to any other BB we have so far. - for (ContourVector::iterator it = contours.begin(); it != contours.end(); ) { - const BoundingBox& ibb = (*it).bb; - - if (BoundingBoxesOverlapping(ibb, bb)) { - - if (!(*it).is_rectangular) { - is_rectangle = false; - } - - const std::vector<IfcVector2>& other = (*it).contour; - ClipperLib::ExPolygons poly; - - // First check whether subtracting the old contour (to which ibb belongs) - // from the new contour (to which bb belongs) yields an updated bb which - // no longer overlaps ibb - MakeDisjunctWindowContours(other, temp_contour, poly); - if(poly.size() == 1) { - - const BoundingBox newbb = GetBoundingBox(poly[0].outer); - if (!BoundingBoxesOverlapping(ibb, newbb )) { - // Good guy bounding box - bb = newbb ; - - ExtractVerticesFromClipper(poly[0].outer, temp_contour, false); - continue; - } - } - - // Take these two overlapping contours and try to merge them. If they - // overlap (which should not happen, but in fact happens-in-the-real- - // world [tm] ), resume using a single contour and a single bounding box. - MergeWindowContours(temp_contour, other, poly); - - if (poly.size() > 1) { - return TryAddOpenings_Poly2Tri(openings, nors, curmesh); - } - else if (poly.size() == 0) { - IFCImporter::LogWarn("ignoring duplicate opening"); - temp_contour.clear(); - break; - } - else { - IFCImporter::LogDebug("merging overlapping openings"); - ExtractVerticesFromClipper(poly[0].outer, temp_contour, false); - - // Generate the union of the bounding boxes - bb.first = std::min(bb.first, ibb.first); - bb.second = std::max(bb.second, ibb.second); - - // Update contour-to-opening tables accordingly - if (generate_connection_geometry) { - std::vector<TempOpening*>& t = contours_to_openings[std::distance(contours.begin(),it)]; - joined_openings.insert(joined_openings.end(), t.begin(), t.end()); - - contours_to_openings.erase(contours_to_openings.begin() + std::distance(contours.begin(),it)); - } - - contours.erase(it); - - // Restart from scratch because the newly formed BB might now - // overlap any other BB which its constituent BBs didn't - // previously overlap. - it = contours.begin(); - continue; - } - } - ++it; - } - - if(!temp_contour.empty()) { - if (generate_connection_geometry) { - contours_to_openings.push_back(std::vector<TempOpening*>( - joined_openings.begin(), - joined_openings.end())); - } - - contours.push_back(ProjectedWindowContour(temp_contour, bb, is_rectangle)); - } - } - - // Check if we still have any openings left - it may well be that this is - // not the cause, for example if all the opening candidates don't intersect - // this surface or point into a direction perpendicular to it. - if (contours.empty()) { - return false; - } - - curmesh.Clear(); - - // Generate a base subdivision into quads to accommodate the given list - // of window bounding boxes. - Quadrify(contours,curmesh); - - // Run a sanity cleanup pass on the window contours to avoid generating - // artifacts during the contour generation phase later on. - CleanupWindowContours(contours); - - // Previously we reduced all windows to rectangular AABBs in projection - // space, now it is time to fill the gaps between the BBs and the real - // window openings. - InsertWindowContours(contours,openings, curmesh); - - // Clip the entire outer contour of our current result against the real - // outer contour of the surface. This is necessary because the result - // of the Quadrify() algorithm is always a square area spanning - // over [0,1]^2 (i.e. entire projection space). - CleanupOuterContour(contour_flat, curmesh); - - // Undo the projection and get back to world (or local object) space - for(IfcVector3& v3 : curmesh.verts) { - v3 = minv * v3; - } - - // Generate window caps to connect the symmetric openings on both sides - // of the wall. - if (generate_connection_geometry) { - CloseWindows(contours, minv, contours_to_openings, curmesh); - } - return true; -} - -// ------------------------------------------------------------------------------------------------ -bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std::vector<IfcVector3>& nors, - TempMesh& curmesh) -{ - IFCImporter::LogWarn("forced to use poly2tri fallback method to generate wall openings"); - std::vector<IfcVector3>& out = curmesh.verts; - - bool result = false; - - // Try to derive a solid base plane within the current surface for use as - // working coordinate system. - bool ok; - IfcVector3 nor; - const IfcMatrix3 m = DerivePlaneCoordinateSpace(curmesh, ok, nor); - if (!ok) { - return false; - } - - const IfcMatrix3 minv = IfcMatrix3(m).Inverse(); - - - IfcFloat coord = -1; - - std::vector<IfcVector2> contour_flat; - contour_flat.reserve(out.size()); - - IfcVector2 vmin, vmax; - MinMaxChooser<IfcVector2>()(vmin, vmax); - - // Move all points into the new coordinate system, collecting min/max verts on the way - for(IfcVector3& x : out) { - const IfcVector3 vv = m * x; - - // keep Z offset in the plane coordinate system. Ignoring precision issues - // (which are present, of course), this should be the same value for - // all polygon vertices (assuming the polygon is planar). - - - // XXX this should be guarded, but we somehow need to pick a suitable - // epsilon - // if(coord != -1.0f) { - // assert(std::fabs(coord - vv.z) < 1e-3f); - // } - - coord = vv.z; - - vmin = std::min(IfcVector2(vv.x, vv.y), vmin); - vmax = std::max(IfcVector2(vv.x, vv.y), vmax); - - contour_flat.push_back(IfcVector2(vv.x,vv.y)); - } - - // With the current code in DerivePlaneCoordinateSpace, - // vmin,vmax should always be the 0...1 rectangle (+- numeric inaccuracies) - // but here we won't rely on this. - - vmax -= vmin; - - // If this happens then the projection must have been wrong. - ai_assert(vmax.Length()); - - ClipperLib::ExPolygons clipped; - ClipperLib::Polygons holes_union; - - - IfcVector3 wall_extrusion; - bool first = true; - - try { - - ClipperLib::Clipper clipper_holes; - size_t c = 0; - - for(const TempOpening& t :openings) { - const IfcVector3& outernor = nors[c++]; - const IfcFloat dot = nor * outernor; - if (std::fabs(dot)<1.f-1e-6f) { - continue; - } - - const std::vector<IfcVector3>& va = t.profileMesh->verts; - if(va.size() <= 2) { - continue; - } - - std::vector<IfcVector2> contour; - - for(const IfcVector3& xx : t.profileMesh->verts) { - IfcVector3 vv = m * xx, vv_extr = m * (xx + t.extrusionDir); - - const bool is_extruded_side = std::fabs(vv.z - coord) > std::fabs(vv_extr.z - coord); - if (first) { - first = false; - if (dot > 0.f) { - wall_extrusion = t.extrusionDir; - if (is_extruded_side) { - wall_extrusion = - wall_extrusion; - } - } - } - - // XXX should not be necessary - but it is. Why? For precision reasons? - vv = is_extruded_side ? vv_extr : vv; - contour.push_back(IfcVector2(vv.x,vv.y)); - } - - ClipperLib::Polygon hole; - for(IfcVector2& pip : contour) { - pip.x = (pip.x - vmin.x) / vmax.x; - pip.y = (pip.y - vmin.y) / vmax.y; - - hole.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - } - - if (!ClipperLib::Orientation(hole)) { - std::reverse(hole.begin(), hole.end()); - // assert(ClipperLib::Orientation(hole)); - } - - /*ClipperLib::Polygons pol_temp(1), pol_temp2(1); - pol_temp[0] = hole; - - ClipperLib::OffsetPolygons(pol_temp,pol_temp2,5.0); - hole = pol_temp2[0];*/ - - clipper_holes.AddPolygon(hole,ClipperLib::ptSubject); - } - - clipper_holes.Execute(ClipperLib::ctUnion,holes_union, - ClipperLib::pftNonZero, - ClipperLib::pftNonZero); - - if (holes_union.empty()) { - return false; - } - - // Now that we have the big union of all holes, subtract it from the outer contour - // to obtain the final polygon to feed into the triangulator. - { - ClipperLib::Polygon poly; - for(IfcVector2& pip : contour_flat) { - pip.x = (pip.x - vmin.x) / vmax.x; - pip.y = (pip.y - vmin.y) / vmax.y; - - poly.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); - } - - if (ClipperLib::Orientation(poly)) { - std::reverse(poly.begin(), poly.end()); - } - clipper_holes.Clear(); - clipper_holes.AddPolygon(poly,ClipperLib::ptSubject); - - clipper_holes.AddPolygons(holes_union,ClipperLib::ptClip); - clipper_holes.Execute(ClipperLib::ctDifference,clipped, - ClipperLib::pftNonZero, - ClipperLib::pftNonZero); - } - - } - catch (const char* sx) { - IFCImporter::LogError("Ifc: error during polygon clipping, skipping openings for this face: (Clipper: " - + std::string(sx) + ")"); - - return false; - } - - std::vector<IfcVector3> old_verts; - std::vector<unsigned int> old_vertcnt; - - old_verts.swap(curmesh.verts); - old_vertcnt.swap(curmesh.vertcnt); - - std::vector< std::vector<p2t::Point*> > contours; - for(ClipperLib::ExPolygon& clip : clipped) { - - contours.clear(); - - // Build the outer polygon contour line for feeding into poly2tri - std::vector<p2t::Point*> contour_points; - for(ClipperLib::IntPoint& point : clip.outer) { - contour_points.push_back( new p2t::Point(from_int64(point.X), from_int64(point.Y)) ); - } - - p2t::CDT* cdt ; - try { - // Note: this relies on custom modifications in poly2tri to raise runtime_error's - // instead if assertions. These failures are not debug only, they can actually - // happen in production use if the input data is broken. An assertion would be - // inappropriate. - cdt = new p2t::CDT(contour_points); - } - catch(const std::exception& e) { - IFCImporter::LogError("Ifc: error during polygon triangulation, skipping some openings: (poly2tri: " - + std::string(e.what()) + ")"); - continue; - } - - - // Build the poly2tri inner contours for all holes we got from ClipperLib - for(ClipperLib::Polygon& opening : clip.holes) { - - contours.push_back(std::vector<p2t::Point*>()); - std::vector<p2t::Point*>& contour = contours.back(); - - for(ClipperLib::IntPoint& point : opening) { - contour.push_back( new p2t::Point(from_int64(point.X), from_int64(point.Y)) ); - } - - cdt->AddHole(contour); - } - - try { - // Note: See above - cdt->Triangulate(); - } - catch(const std::exception& e) { - IFCImporter::LogError("Ifc: error during polygon triangulation, skipping some openings: (poly2tri: " - + std::string(e.what()) + ")"); - continue; - } - - const std::vector<p2t::Triangle*> tris = cdt->GetTriangles(); - - // Collect the triangles we just produced - for(p2t::Triangle* tri : tris) { - for(int i = 0; i < 3; ++i) { - - const IfcVector2 v = IfcVector2( - static_cast<IfcFloat>( tri->GetPoint(i)->x ), - static_cast<IfcFloat>( tri->GetPoint(i)->y ) - ); - - ai_assert(v.x <= 1.0 && v.x >= 0.0 && v.y <= 1.0 && v.y >= 0.0); - const IfcVector3 v3 = minv * IfcVector3(vmin.x + v.x * vmax.x, vmin.y + v.y * vmax.y,coord) ; - - curmesh.verts.push_back(v3); - } - curmesh.vertcnt.push_back(3); - } - - result = true; - } - - if (!result) { - // revert -- it's a shame, but better than nothing - curmesh.verts.insert(curmesh.verts.end(),old_verts.begin(), old_verts.end()); - curmesh.vertcnt.insert(curmesh.vertcnt.end(),old_vertcnt.begin(), old_vertcnt.end()); - - IFCImporter::LogError("Ifc: revert, could not generate openings for this wall"); - } - - return result; -} - - - } // ! IFC -} // ! Assimp - -#undef to_int64 -#undef from_int64 -#undef one_vec - -#endif |