From e867c7332754f3852506b160330ac79966d9dc95 Mon Sep 17 00:00:00 2001 From: aramis_acg Date: Thu, 2 Feb 2012 02:09:49 +0000 Subject: [PATCH] - Ifc: make code base ready for running double precision by using the new math templates with a customizable float type, IfcFloat. (still using floats with this commit). git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@1133 67173fc5-114c-0410-ac8e-9d2fd5bffc1f --- code/IFCCurve.cpp | 116 ++++++------- code/IFCGeometry.cpp | 392 +++++++++++++++++++++---------------------- code/IFCLoader.cpp | 16 +- code/IFCMaterial.cpp | 8 +- code/IFCProfile.cpp | 20 +-- code/IFCUtil.cpp | 102 +++++------ code/IFCUtil.h | 72 ++++---- 7 files changed, 368 insertions(+), 358 deletions(-) diff --git a/code/IFCCurve.cpp b/code/IFCCurve.cpp index c91c47105..c7a90aab7 100644 --- a/code/IFCCurve.cpp +++ b/code/IFCCurve.cpp @@ -64,14 +64,14 @@ public: Conic(const IfcConic& entity, ConversionData& conv) : Curve(entity,conv) { - aiMatrix4x4 trafo; + IfcMatrix4 trafo; ConvertAxisPlacement(trafo,*entity.Position,conv); // for convenience, extract the matrix rows - location = aiVector3D(trafo.a4,trafo.b4,trafo.c4); - p[0] = aiVector3D(trafo.a1,trafo.b1,trafo.c1); - p[1] = aiVector3D(trafo.a2,trafo.b2,trafo.c2); - p[2] = aiVector3D(trafo.a3,trafo.b3,trafo.c3); + location = IfcVector3(trafo.a4,trafo.b4,trafo.c4); + p[0] = IfcVector3(trafo.a1,trafo.b1,trafo.c1); + p[1] = IfcVector3(trafo.a2,trafo.b2,trafo.c2); + p[2] = IfcVector3(trafo.a3,trafo.b3,trafo.c3); } public: @@ -82,21 +82,21 @@ public: } // -------------------------------------------------- - size_t EstimateSampleCount(float a, float b) const { + size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); - a = fmod(a,360.f); - b = fmod(b,360.f); - return static_cast( fabs(ceil(( b-a)) / conv.settings.conicSamplingAngle) ); + a = fmod(a,static_cast( 360. )); + b = fmod(b,static_cast( 360. )); + return static_cast( abs(ceil(( b-a)) / conv.settings.conicSamplingAngle) ); } // -------------------------------------------------- ParamRange GetParametricRange() const { - return std::make_pair(0.f,360.f); + return std::make_pair(static_cast( 0. ), static_cast( 360. )); } protected: - aiVector3D location, p[3]; + IfcVector3 location, p[3]; }; @@ -118,7 +118,7 @@ public: public: // -------------------------------------------------- - aiVector3D Eval(float u) const { + IfcVector3 Eval(IfcFloat u) const { u = -conv.angle_scale * u; return location + entity.Radius*(::cos(u)*p[0] + ::sin(u)*p[1]); } @@ -146,7 +146,7 @@ public: public: // -------------------------------------------------- - aiVector3D Eval(float u) const { + IfcVector3 Eval(IfcFloat u) const { u = -conv.angle_scale * u; return location + entity.SemiAxis1*::cos(u)*p[0] + entity.SemiAxis2*::sin(u)*p[1]; } @@ -181,12 +181,12 @@ public: } // -------------------------------------------------- - aiVector3D Eval(float u) const { + IfcVector3 Eval(IfcFloat u) const { return p + u*v; } // -------------------------------------------------- - size_t EstimateSampleCount(float a, float b) const { + size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); // two points are always sufficient for a line segment return a==b ? 1 : 2; @@ -194,7 +194,7 @@ public: // -------------------------------------------------- - void SampleDiscrete(TempMesh& out,float a, float b) const + void SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); @@ -209,14 +209,14 @@ public: // -------------------------------------------------- ParamRange GetParametricRange() const { - const float inf = std::numeric_limits::infinity(); + const IfcFloat inf = std::numeric_limits::infinity(); return std::make_pair(-inf,+inf); } private: const IfcLine& entity; - aiVector3D p,v; + IfcVector3 p,v; }; // -------------------------------------------------------------------------------- @@ -262,15 +262,15 @@ public: public: // -------------------------------------------------- - aiVector3D Eval(float u) const { + IfcVector3 Eval(IfcFloat u) const { if (curves.empty()) { - return aiVector3D(); + return IfcVector3(); } - float acc = 0; + IfcFloat acc = 0; BOOST_FOREACH(const CurveEntry& entry, curves) { const ParamRange& range = entry.first->GetParametricRange(); - const float delta = range.second-range.first; + const IfcFloat delta = range.second-range.first; if (u < acc+delta) { return entry.first->Eval( entry.second ? (u-acc) + range.first : range.second-(u-acc)); } @@ -282,16 +282,16 @@ public: } // -------------------------------------------------- - size_t EstimateSampleCount(float a, float b) const { + size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); size_t cnt = 0; - float acc = 0; + IfcFloat acc = 0; BOOST_FOREACH(const CurveEntry& entry, curves) { const ParamRange& range = entry.first->GetParametricRange(); - const float delta = range.second-range.first; + const IfcFloat delta = range.second-range.first; if (a <= acc+delta && b >= acc) { - const float at = std::max(0.f,a-acc), bt = std::min(delta,b-acc); + const IfcFloat at = std::max(static_cast( 0. ),a-acc), bt = std::min(delta,b-acc); cnt += entry.first->EstimateSampleCount( entry.second ? at + range.first : range.second - bt, entry.second ? bt + range.first : range.second - at ); } @@ -302,7 +302,7 @@ public: } // -------------------------------------------------- - void SampleDiscrete(TempMesh& out,float a, float b) const + void SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); @@ -321,14 +321,14 @@ public: // -------------------------------------------------- ParamRange GetParametricRange() const { - return std::make_pair(0.f,total); + return std::make_pair(static_cast( 0. ),total); } private: const IfcCompositeCurve& entity; std::vector< CurveEntry > curves; - float total; + IfcFloat total; }; @@ -356,7 +356,7 @@ public: // claims that they must be identical if both are present. // oh well. bool have_param = false, have_point = false; - aiVector3D point; + IfcVector3 point; BOOST_FOREACH(const Entry sel,entity.Trim1) { if (const EXPRESS::REAL* const r = sel->ToPtr()) { range.first = *r; @@ -411,26 +411,26 @@ public: public: // -------------------------------------------------- - aiVector3D Eval(float p) const { + IfcVector3 Eval(IfcFloat p) const { ai_assert(InRange(p)); return base->Eval( TrimParam(p) ); } // -------------------------------------------------- - size_t EstimateSampleCount(float a, float b) const { + size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); return base->EstimateSampleCount(TrimParam(a),TrimParam(b)); } // -------------------------------------------------- ParamRange GetParametricRange() const { - return std::make_pair(0.f,maxval); + return std::make_pair(static_cast( 0. ),maxval); } private: // -------------------------------------------------- - float TrimParam(float f) const { + IfcFloat TrimParam(IfcFloat f) const { return agree_sense ? f + range.first : range.second - f; } @@ -438,7 +438,7 @@ private: private: const IfcTrimmedCurve& entity; ParamRange range; - float maxval; + IfcFloat maxval; bool agree_sense; bool ok; @@ -461,7 +461,7 @@ public: { points.reserve(entity.Points.size()); - aiVector3D t; + IfcVector3 t; BOOST_FOREACH(const IfcCartesianPoint& cp, entity.Points) { ConvertCartesianPoint(t,cp); points.push_back(t); @@ -471,7 +471,7 @@ public: public: // -------------------------------------------------- - aiVector3D Eval(float p) const { + IfcVector3 Eval(IfcFloat p) const { ai_assert(InRange(p)); const size_t b = static_cast(floor(p)); @@ -479,24 +479,24 @@ public: return points.back(); } - const float d = p-static_cast(b); - return points[b+1] * d + points[b] * (1.f-d); + const IfcFloat d = p-static_cast(b); + return points[b+1] * d + points[b] * (static_cast( 1. )-d); } // -------------------------------------------------- - size_t EstimateSampleCount(float a, float b) const { + size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); return static_cast( ceil(b) - floor(a) ); } // -------------------------------------------------- ParamRange GetParametricRange() const { - return std::make_pair(0.f,static_cast(points.size()-1)); + return std::make_pair(static_cast( 0. ),static_cast(points.size()-1)); } private: const IfcPolyline& entity; - std::vector points; + std::vector points; }; @@ -540,11 +540,11 @@ Curve* Curve :: Convert(const IFC::IfcCurve& curve,ConversionData& conv) #ifdef _DEBUG // ------------------------------------------------------------------------------------------------ -bool Curve :: InRange(float u) const +bool Curve :: InRange(IfcFloat u) const { const ParamRange range = GetParametricRange(); if (IsClosed()) { - ai_assert(range.first != std::numeric_limits::infinity() && range.second != std::numeric_limits::infinity()); + ai_assert(range.first != std::numeric_limits::infinity() && range.second != std::numeric_limits::infinity()); u = range.first + fmod(u-range.first,range.second-range.first); } return u >= range.first && u <= range.second; @@ -552,14 +552,14 @@ bool Curve :: InRange(float u) const #endif // ------------------------------------------------------------------------------------------------ -float Curve :: GetParametricRangeDelta() const +IfcFloat Curve :: GetParametricRangeDelta() const { const ParamRange& range = GetParametricRange(); return range.second - range.first; } // ------------------------------------------------------------------------------------------------ -size_t Curve :: EstimateSampleCount(float a, float b) const +size_t Curve :: EstimateSampleCount(IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); @@ -568,16 +568,16 @@ size_t Curve :: EstimateSampleCount(float a, float b) const } // ------------------------------------------------------------------------------------------------ -float RecursiveSearch(const Curve* cv, const aiVector3D& val, float a, float b, unsigned int samples, float threshold, unsigned int recurse = 0, unsigned int max_recurse = 15) +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) { ai_assert(samples>1); - const float delta = (b-a)/samples, inf = std::numeric_limits::infinity(); - float min_point[2] = {a,b}, min_diff[2] = {inf,inf}; - float runner = a; + const IfcFloat delta = (b-a)/samples, inf = std::numeric_limits::infinity(); + IfcFloat min_point[2] = {a,b}, min_diff[2] = {inf,inf}; + IfcFloat runner = a; for (unsigned int i = 0; i < samples; ++i, runner += delta) { - const float diff = (cv->Eval(runner)-val).SquareLength(); + const IfcFloat diff = (cv->Eval(runner)-val).SquareLength(); if (diff < min_diff[0]) { min_diff[1] = min_diff[0]; min_point[1] = min_point[0]; @@ -599,10 +599,10 @@ float RecursiveSearch(const Curve* cv, const aiVector3D& val, float a, float b, // fix for closed curves to take their wrap-over into account if (cv->IsClosed() && fabs(min_point[0]-min_point[1]) > cv->GetParametricRangeDelta()*0.5 ) { const Curve::ParamRange& range = cv->GetParametricRange(); - const float wrapdiff = (cv->Eval(range.first)-val).SquareLength(); + const IfcFloat wrapdiff = (cv->Eval(range.first)-val).SquareLength(); if (wrapdiff < min_diff[0]) { - const float t = min_point[0]; + const IfcFloat t = min_point[0]; min_point[0] = min_point[1] > min_point[0] ? range.first : range.second; min_point[1] = t; } @@ -612,14 +612,14 @@ float RecursiveSearch(const Curve* cv, const aiVector3D& val, float a, float b, } // ------------------------------------------------------------------------------------------------ -bool Curve :: ReverseEval(const aiVector3D& val, float& paramOut) const +bool Curve :: ReverseEval(const IfcVector3& val, IfcFloat& paramOut) const { // note: the following algorithm is not guaranteed to find the 'right' parameter value // in all possible cases, but it will always return at least some value so this function // will never fail in the default implementation. // XXX derive threshold from curve topology - const float threshold = 1e-4f; + const IfcFloat threshold = 1e-4f; const unsigned int samples = 16; const ParamRange& range = GetParametricRange(); @@ -629,14 +629,14 @@ bool Curve :: ReverseEval(const aiVector3D& val, float& paramOut) const } // ------------------------------------------------------------------------------------------------ -void Curve :: SampleDiscrete(TempMesh& out,float a, float b) const +void Curve :: SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const { ai_assert(InRange(a) && InRange(b)); const size_t cnt = std::max(static_cast(0),EstimateSampleCount(a,b)); out.verts.reserve( out.verts.size() + cnt ); - float p = a, delta = (b-a)/cnt; + IfcFloat p = a, delta = (b-a)/cnt; for(size_t i = 0; i < cnt; ++i, p += delta) { out.verts.push_back(Eval(p)); } @@ -652,7 +652,7 @@ bool BoundedCurve :: IsClosed() const void BoundedCurve :: SampleDiscrete(TempMesh& out) const { const ParamRange& range = GetParametricRange(); - ai_assert(range.first != std::numeric_limits::infinity() && range.second != std::numeric_limits::infinity()); + ai_assert(range.first != std::numeric_limits::infinity() && range.second != std::numeric_limits::infinity()); return SampleDiscrete(out,range.first,range.second); } diff --git a/code/IFCGeometry.cpp b/code/IFCGeometry.cpp index 7fa56f813..3c0910ab9 100644 --- a/code/IFCGeometry.cpp +++ b/code/IFCGeometry.cpp @@ -61,17 +61,17 @@ namespace Assimp { // XXX use full -+ range ... const ClipperLib::long64 max_ulong64 = 1518500249; // clipper.cpp / hiRange var - //#define to_int64(p) (static_cast( std::max( 0., std::min( static_cast((p)), 1.) ) * max_ulong64 )) -#define to_int64(p) (static_cast(static_cast((p) ) * max_ulong64 )) -#define from_int64(p) (static_cast((p)) / max_ulong64) -#define from_int64_f(p) (static_cast(from_int64((p)))) + //#define to_int64(p) (static_cast( std::max( 0., std::min( static_cast((p)), 1.) ) * max_ulong64 )) +#define to_int64(p) (static_cast(static_cast((p) ) * max_ulong64 )) +#define from_int64(p) (static_cast((p)) / max_ulong64) +#define from_int64_f(p) (static_cast(from_int64((p)))) // ------------------------------------------------------------------------------------------------ bool ProcessPolyloop(const IfcPolyLoop& loop, TempMesh& meshout, ConversionData& /*conv*/) { size_t cnt = 0; BOOST_FOREACH(const IfcCartesianPoint& c, loop.Polygon) { - aiVector3D tmp; + IfcVector3 tmp; ConvertCartesianPoint(tmp,c); meshout.verts.push_back(tmp); @@ -93,7 +93,7 @@ bool ProcessPolyloop(const IfcPolyLoop& loop, TempMesh& meshout, ConversionData& } // ------------------------------------------------------------------------------------------------ -void ComputePolygonNormals(const TempMesh& meshout, std::vector& normals, bool normalize = true, size_t ofs = 0) +void ComputePolygonNormals(const TempMesh& meshout, std::vector& normals, bool normalize = true, size_t ofs = 0) { size_t max_vcount = 0; std::vector::const_iterator begin=meshout.vertcnt.begin()+ofs, end=meshout.vertcnt.end(), iit; @@ -101,7 +101,7 @@ void ComputePolygonNormals(const TempMesh& meshout, std::vector& nor max_vcount = std::max(max_vcount,static_cast(*iit)); } - std::vector temp((max_vcount+2)*4); + std::vector temp((max_vcount+2)*4); normals.reserve( normals.size() + meshout.vertcnt.size()-ofs ); // `NewellNormal()` currently has a relatively strange interface and need to @@ -109,26 +109,26 @@ void ComputePolygonNormals(const TempMesh& meshout, std::vector& nor size_t vidx = std::accumulate(meshout.vertcnt.begin(),begin,0); for(iit = begin; iit != end; vidx += *iit++) { if (!*iit) { - normals.push_back(aiVector3D()); + normals.push_back(IfcVector3()); continue; } for(size_t vofs = 0, cnt = 0; vofs < *iit; ++vofs) { - const aiVector3D& v = meshout.verts[vidx+vofs]; + const IfcVector3& v = meshout.verts[vidx+vofs]; temp[cnt++] = v.x; temp[cnt++] = v.y; temp[cnt++] = v.z; #ifdef _DEBUG - temp[cnt] = std::numeric_limits::quiet_NaN(); + temp[cnt] = std::numeric_limits::quiet_NaN(); #endif ++cnt; } - normals.push_back(aiVector3D()); + normals.push_back(IfcVector3()); NewellNormal<4,4,4>(normals.back(),*iit,&temp[0],&temp[1],&temp[2]); } if(normalize) { - BOOST_FOREACH(aiVector3D& n, normals) { + BOOST_FOREACH(IfcVector3& n, normals) { n.Normalize(); } } @@ -136,17 +136,17 @@ void ComputePolygonNormals(const TempMesh& meshout, std::vector& nor // ------------------------------------------------------------------------------------------------ // Compute the normal of the last polygon in the given mesh -aiVector3D ComputePolygonNormal(const TempMesh& inmesh, bool normalize = true) +IfcVector3 ComputePolygonNormal(const TempMesh& inmesh, bool normalize = true) { size_t total = inmesh.vertcnt.back(), vidx = inmesh.verts.size() - total; - std::vector temp((total+2)*3); + std::vector temp((total+2)*3); for(size_t vofs = 0, cnt = 0; vofs < total; ++vofs) { - const aiVector3D& v = inmesh.verts[vidx+vofs]; + const IfcVector3& v = inmesh.verts[vidx+vofs]; temp[cnt++] = v.x; temp[cnt++] = v.y; temp[cnt++] = v.z; } - aiVector3D nor; + IfcVector3 nor; NewellNormal<3,3,3>(nor,total,&temp[0],&temp[1],&temp[2]); return normalize ? nor.Normalize() : nor; } @@ -154,15 +154,15 @@ aiVector3D ComputePolygonNormal(const TempMesh& inmesh, bool normalize = true) // ------------------------------------------------------------------------------------------------ void FixupFaceOrientation(TempMesh& result) { - const aiVector3D vavg = result.Center(); + const IfcVector3 vavg = result.Center(); - std::vector normals; + std::vector normals; ComputePolygonNormals(result,normals); size_t c = 0, ofs = 0; BOOST_FOREACH(unsigned int cnt, result.vertcnt) { if (cnt>2){ - const aiVector3D& thisvert = result.verts[c]; + const IfcVector3& thisvert = result.verts[c]; if (normals[ofs]*(thisvert-vavg) < 0) { std::reverse(result.verts.begin()+c,result.verts.begin()+cnt+c); } @@ -173,7 +173,7 @@ void FixupFaceOrientation(TempMesh& result) } // ------------------------------------------------------------------------------------------------ -void RecursiveMergeBoundaries(TempMesh& final_result, const TempMesh& in, const TempMesh& boundary, std::vector& normals, const aiVector3D& nor_boundary) +void RecursiveMergeBoundaries(TempMesh& final_result, const TempMesh& in, const TempMesh& boundary, std::vector& normals, const IfcVector3& nor_boundary) { ai_assert(in.vertcnt.size() >= 1); ai_assert(boundary.vertcnt.size() == 1); @@ -185,15 +185,15 @@ void RecursiveMergeBoundaries(TempMesh& final_result, const TempMesh& in, const // to the outer boundary is actually the shortest possible. size_t vidx = 0, best_vidx_start = 0; size_t best_ofs, best_outer = boundary.verts.size(); - float best_dist = 1e10; + IfcFloat best_dist = 1e10; for(std::vector::const_iterator iit = begin; iit != end; vidx += *iit++) { for(size_t vofs = 0; vofs < *iit; ++vofs) { - const aiVector3D& v = in.verts[vidx+vofs]; + const IfcVector3& v = in.verts[vidx+vofs]; for(size_t outer = 0; outer < boundary.verts.size(); ++outer) { - const aiVector3D& o = boundary.verts[outer]; - const float d = (o-v).SquareLength(); + const IfcVector3& o = boundary.verts[outer]; + const IfcFloat d = (o-v).SquareLength(); if (d < best_dist) { best_dist = d; @@ -214,7 +214,7 @@ void RecursiveMergeBoundaries(TempMesh& final_result, const TempMesh& in, const out.verts.reserve(cnt); for(size_t outer = 0; outer < boundary.verts.size(); ++outer) { - const aiVector3D& o = boundary.verts[outer]; + const IfcVector3& o = boundary.verts[outer]; out.verts.push_back(o); if (outer == best_outer) { @@ -286,12 +286,12 @@ void MergePolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t mas size_t outer_polygon_start = 0; // do not normalize 'normals', we need the original length for computing the polygon area - std::vector normals; + std::vector normals; ComputePolygonNormals(meshout,normals,false); // see if one of the polygons is a IfcFaceOuterBound (in which case `master_bounds` is its index). // sadly we can't rely on it, the docs say 'At most one of the bounds shall be of the type IfcFaceOuterBound' - float area_outer_polygon = 1e-10f; + IfcFloat area_outer_polygon = 1e-10f; if (master_bounds != (size_t)-1) { outer_polygon = begin + master_bounds; outer_polygon_start = std::accumulate(begin,outer_polygon,0); @@ -301,8 +301,8 @@ void MergePolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t mas size_t vidx = 0; for(iit = begin; iit != meshout.vertcnt.end(); vidx += *iit++) { // find the polygon with the largest area, it must be the outer bound. - aiVector3D& n = normals[std::distance(begin,iit)]; - const float area = n.SquareLength(); + IfcVector3& n = normals[std::distance(begin,iit)]; + const IfcFloat area = n.SquareLength(); if (area > area_outer_polygon) { area_outer_polygon = area; outer_polygon = iit; @@ -312,18 +312,18 @@ void MergePolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t mas } ai_assert(outer_polygon != meshout.vertcnt.end()); - std::vector& in = meshout.verts; + std::vector& in = meshout.verts; // skip over extremely small boundaries - this is a workaround to fix cases // in which the number of holes is so extremely large that the // triangulation code fails. #define IFC_VERTICAL_HOLE_SIZE_THRESHOLD 0.000001f size_t vidx = 0, removed = 0, index = 0; - const float threshold = area_outer_polygon * IFC_VERTICAL_HOLE_SIZE_THRESHOLD; + const IfcFloat threshold = area_outer_polygon * IFC_VERTICAL_HOLE_SIZE_THRESHOLD; for(iit = begin; iit != end ;++index) { - const float sqlen = normals[index].SquareLength(); + const IfcFloat sqlen = normals[index].SquareLength(); if (sqlen < threshold) { - std::vector::iterator inbase = in.begin()+vidx; + std::vector::iterator inbase = in.begin()+vidx; in.erase(inbase,inbase+*iit); outer_polygon_start -= outer_polygon_start>vidx ? *iit : 0; @@ -355,19 +355,19 @@ next_loop: continue; } const size_t next = (vofs+1)%*iit; - const aiVector3D& v = in[vidx+vofs], &vnext = in[vidx+next],&vd = (vnext-v).Normalize(); + const IfcVector3& v = in[vidx+vofs], &vnext = in[vidx+next],&vd = (vnext-v).Normalize(); for(size_t outer = 0; outer < *outer_polygon; ++outer) { - const aiVector3D& o = in[outer_polygon_start+outer], &onext = in[outer_polygon_start+(outer+1)%*outer_polygon], &od = (onext-o).Normalize(); + const IfcVector3& o = in[outer_polygon_start+outer], &onext = in[outer_polygon_start+(outer+1)%*outer_polygon], &od = (onext-o).Normalize(); if (fabs(vd * od) > 1.f-1e-6f && (onext-v).Normalize() * vd > 1.f-1e-6f && (onext-v)*(o-v) < 0) { IFCImporter::LogDebug("got an inner hole that lies partly on the outer polygonal boundary, merging them to a single contour"); // in between outer and outer+1 insert all vertices of this loop, then drop the original altogether. - std::vector tmp(*iit); + std::vector tmp(*iit); const size_t start = (v-o).SquareLength() > (vnext-o).SquareLength() ? vofs : next; - std::vector::iterator inbase = in.begin()+vidx, it = std::copy(inbase+start, inbase+*iit,tmp.begin()); + std::vector::iterator inbase = in.begin()+vidx, it = std::copy(inbase+start, inbase+*iit,tmp.begin()); std::copy(inbase, inbase+start,it); std::reverse(tmp.begin(),tmp.end()); @@ -398,12 +398,12 @@ next_loop: boundary.vertcnt.resize(1,*outer_polygon); boundary.verts.resize(*outer_polygon); - std::vector::iterator b = in.begin()+outer_polygon_start; + std::vector::iterator b = in.begin()+outer_polygon_start; std::copy(b,b+*outer_polygon,boundary.verts.begin()); in.erase(b,b+*outer_polygon); - std::vector::iterator norit = normals.begin()+std::distance(meshout.vertcnt.begin(),outer_polygon); - const aiVector3D nor_boundary = *norit; + std::vector::iterator norit = normals.begin()+std::distance(meshout.vertcnt.begin(),outer_polygon); + const IfcVector3 nor_boundary = *norit; normals.erase(norit); meshout.vertcnt.erase(outer_polygon); @@ -463,18 +463,18 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul return; } - aiVector3D axis, pos; + IfcVector3 axis, pos; ConvertAxisPlacement(axis,pos,solid.Axis); - aiMatrix4x4 tb0,tb1; - aiMatrix4x4::Translation(pos,tb0); - aiMatrix4x4::Translation(-pos,tb1); + IfcMatrix4 tb0,tb1; + IfcMatrix4::Translation(pos,tb0); + IfcMatrix4::Translation(-pos,tb1); - const std::vector& in = meshout.verts; + const std::vector& in = meshout.verts; const size_t size=in.size(); bool has_area = solid.SweptArea->ProfileType == "AREA" && size>2; - const float max_angle = solid.Angle*conv.angle_scale; + const IfcFloat max_angle = solid.Angle*conv.angle_scale; if(fabs(max_angle) < 1e-3) { if(has_area) { result = meshout; @@ -483,18 +483,18 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul } const unsigned int cnt_segments = std::max(2u,static_cast(16 * fabs(max_angle)/AI_MATH_HALF_PI_F)); - const float delta = max_angle/cnt_segments; + const IfcFloat delta = max_angle/cnt_segments; has_area = has_area && fabs(max_angle) < AI_MATH_TWO_PI_F*0.99; result.verts.reserve(size*((cnt_segments+1)*4+(has_area?2:0))); result.vertcnt.reserve(size*cnt_segments+2); - aiMatrix4x4 rot; - rot = tb0 * aiMatrix4x4::Rotation(delta,axis,rot) * tb1; + IfcMatrix4 rot; + rot = tb0 * IfcMatrix4::Rotation(delta,axis,rot) * tb1; size_t base = 0; - std::vector& out = result.verts; + std::vector& out = result.verts; // dummy data to simplify later processing for(size_t i = 0; i < size; ++i) { @@ -506,7 +506,7 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul const size_t next = (i+1)%size; result.vertcnt.push_back(4); - const aiVector3D& base_0 = out[base+i*4+3],base_1 = out[base+next*4+3]; + const IfcVector3& base_0 = out[base+i*4+3],base_1 = out[base+next*4+3]; out.push_back(base_0); out.push_back(base_1); @@ -533,7 +533,7 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul result.vertcnt.push_back(size); } - aiMatrix4x4 trafo; + IfcMatrix4 trafo; ConvertAxisPlacement(trafo, solid.Position); result.Transform(trafo); @@ -541,16 +541,16 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul } // ------------------------------------------------------------------------------------------------ -aiMatrix3x3 DerivePlaneCoordinateSpace(const TempMesh& curmesh) { +IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh) { - const std::vector& out = curmesh.verts; - aiMatrix3x3 m; + const std::vector& out = curmesh.verts; + IfcMatrix3 m; const size_t s = out.size(); assert(curmesh.vertcnt.size() == 1 && curmesh.vertcnt.back() == s); - const aiVector3D any_point = out[s-1]; - aiVector3D nor; + const IfcVector3 any_point = out[s-1]; + IfcVector3 nor; // The input polygon is arbitrarily shaped, so we might need some tries // until we find a suitable normal (and it does not even need to be @@ -571,11 +571,11 @@ out: nor.Normalize(); - aiVector3D r = (out[i]-any_point); + IfcVector3 r = (out[i]-any_point); r.Normalize(); // reconstruct orthonormal basis - aiVector3D u = r ^ nor; + IfcVector3 u = r ^ nor; u.Normalize(); m.a1 = r.x; @@ -594,29 +594,29 @@ out: } // ------------------------------------------------------------------------------------------------ -bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std::vector& nors, TempMesh& curmesh) +bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std::vector& nors, TempMesh& curmesh) { - std::vector& out = curmesh.verts; + std::vector& out = curmesh.verts; bool result = false; // Try to derive a solid base plane within the current surface for use as // working coordinate system. - const aiMatrix3x3& m = DerivePlaneCoordinateSpace(curmesh); - const aiMatrix3x3 minv = aiMatrix3x3(m).Inverse(); - const aiVector3D& nor = aiVector3D(m.c1, m.c2, m.c3); + const IfcMatrix3& m = DerivePlaneCoordinateSpace(curmesh); + const IfcMatrix3 minv = IfcMatrix3(m).Inverse(); + const IfcVector3& nor = IfcVector3(m.c1, m.c2, m.c3); - float coord = -1; + IfcFloat coord = -1; - std::vector contour_flat; + std::vector contour_flat; contour_flat.reserve(out.size()); - aiVector2D vmin, vmax; - MinMaxChooser()(vmin, vmax); + IfcVector2 vmin, vmax; + MinMaxChooser()(vmin, vmax); // Move all points into the new coordinate system, collecting min/max verts on the way - BOOST_FOREACH(aiVector3D& x, out) { - const aiVector3D vv = m * x; + BOOST_FOREACH(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 @@ -631,10 +631,10 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: coord = vv.z; - vmin = std::min(aiVector2D(vv.x, vv.y), vmin); - vmax = std::max(aiVector2D(vv.x, vv.y), vmax); + vmin = std::min(IfcVector2(vv.x, vv.y), vmin); + vmax = std::max(IfcVector2(vv.x, vv.y), vmax); - contour_flat.push_back(aiVector2D(vv.x,vv.y)); + contour_flat.push_back(IfcVector2(vv.x,vv.y)); } // With the current code in DerivePlaneCoordinateSpace, @@ -650,7 +650,7 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: ClipperLib::Polygons holes_union; - aiVector3D wall_extrusion; + IfcVector3 wall_extrusion; bool do_connections = false, first = true; try { @@ -659,21 +659,21 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: size_t c = 0; BOOST_FOREACH(const TempOpening& t,openings) { - const aiVector3D& outernor = nors[c++]; - const float dot = nor * outernor; + const IfcVector3& outernor = nors[c++]; + const IfcFloat dot = nor * outernor; if (fabs(dot)<1.f-1e-6f) { continue; } - const std::vector& va = t.profileMesh->verts; + const std::vector& va = t.profileMesh->verts; if(va.size() <= 2) { continue; } - std::vector contour; + std::vector contour; - BOOST_FOREACH(const aiVector3D& xx, t.profileMesh->verts) { - aiVector3D vv = m * xx, vv_extr = m * (xx + t.extrusionDir); + BOOST_FOREACH(const IfcVector3& xx, t.profileMesh->verts) { + IfcVector3 vv = m * xx, vv_extr = m * (xx + t.extrusionDir); const bool is_extruded_side = fabs(vv.z - coord) > fabs(vv_extr.z - coord); if (first) { @@ -689,11 +689,11 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: // XXX should not be necessary - but it is. Why? For precision reasons? vv = is_extruded_side ? vv_extr : vv; - contour.push_back(aiVector2D(vv.x,vv.y)); + contour.push_back(IfcVector2(vv.x,vv.y)); } ClipperLib::Polygon hole; - BOOST_FOREACH(aiVector2D& pip, contour) { + BOOST_FOREACH(IfcVector2& pip, contour) { pip.x = (pip.x - vmin.x) / vmax.x; pip.y = (pip.y - vmin.y) / vmax.y; @@ -720,7 +720,7 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: // to obtain the final polygon to feed into the triangulator. { ClipperLib::Polygon poly; - BOOST_FOREACH(aiVector2D& pip, contour_flat) { + BOOST_FOREACH(IfcVector2& pip, contour_flat) { pip.x = (pip.x - vmin.x) / vmax.x; pip.y = (pip.y - vmin.y) / vmax.y; @@ -747,7 +747,7 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: return false; } - std::vector old_verts; + std::vector old_verts; std::vector old_vertcnt; old_verts.swap(curmesh.verts); @@ -759,7 +759,7 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: // would be emitted twice. if (false && do_connections) { - std::vector tmpvec; + std::vector tmpvec; BOOST_FOREACH(ClipperLib::Polygon& opening, holes_union) { assert(ClipperLib::Orientation(opening)); @@ -768,7 +768,7 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: BOOST_FOREACH(ClipperLib::IntPoint& point, opening) { - tmpvec.push_back( minv * aiVector3D( + tmpvec.push_back( minv * IfcVector3( vmin.x + from_int64_f(point.X) * vmax.x, vmin.y + from_int64_f(point.Y) * vmax.y, coord)); @@ -779,8 +779,8 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: curmesh.vertcnt.push_back(4); - const aiVector3D& in_world = tmpvec[i]; - const aiVector3D& next_world = tmpvec[next]; + const IfcVector3& in_world = tmpvec[i]; + const IfcVector3& next_world = tmpvec[next]; // Assumptions: no 'partial' openings, wall thickness roughly the same across the wall curmesh.verts.push_back(in_world); @@ -846,13 +846,13 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: BOOST_FOREACH(p2t::Triangle* tri, tris) { for(int i = 0; i < 3; ++i) { - const aiVector2D& v = aiVector2D( - static_cast( tri->GetPoint(i)->x ), - static_cast( tri->GetPoint(i)->y ) + const IfcVector2& v = IfcVector2( + static_cast( tri->GetPoint(i)->x ), + static_cast( tri->GetPoint(i)->y ) ); assert(v.x <= 1.0 && v.x >= 0.0 && v.y <= 1.0 && v.y >= 0.0); - const aiVector3D v3 = minv * aiVector3D(vmin.x + v.x * vmax.x, vmin.y + v.y * vmax.y,coord) ; + const IfcVector3 v3 = minv * IfcVector3(vmin.x + v.x * vmax.x, vmin.y + v.y * vmax.y,coord) ; curmesh.verts.push_back(v3); } @@ -876,20 +876,20 @@ bool TryAddOpenings_Poly2Tri(const std::vector& openings,const std: // ------------------------------------------------------------------------------------------------ struct DistanceSorter { - DistanceSorter(const aiVector3D& base) : base(base) {} + DistanceSorter(const IfcVector3& base) : base(base) {} bool operator () (const TempOpening& a, const TempOpening& b) const { return (a.profileMesh->Center()-base).SquareLength() < (b.profileMesh->Center()-base).SquareLength(); } - aiVector3D base; + IfcVector3 base; }; // ------------------------------------------------------------------------------------------------ struct XYSorter { // sort first by X coordinates, then by Y coordinates - bool operator () (const aiVector2D&a, const aiVector2D& b) const { + bool operator () (const IfcVector2&a, const IfcVector2& b) const { if (a.x == b.x) { return a.y < b.y; } @@ -897,19 +897,19 @@ struct XYSorter { } }; -typedef std::pair< aiVector2D, aiVector2D > BoundingBox; -typedef std::map XYSortedField; +typedef std::pair< IfcVector2, IfcVector2 > BoundingBox; +typedef std::map XYSortedField; // ------------------------------------------------------------------------------------------------ -void QuadrifyPart(const aiVector2D& pmin, const aiVector2D& pmax, XYSortedField& field, const std::vector< BoundingBox >& bbs, - std::vector& out) +void QuadrifyPart(const IfcVector2& pmin, const IfcVector2& pmax, XYSortedField& field, const std::vector< BoundingBox >& bbs, + std::vector& out) { if (!(pmin.x-pmax.x) || !(pmin.y-pmax.y)) { return; } - float xs = 1e10, xe = 1e10; + IfcFloat xs = 1e10, xe = 1e10; bool found = false; // Search along the x-axis until we find an opening @@ -931,9 +931,9 @@ void QuadrifyPart(const aiVector2D& pmin, const aiVector2D& pmax, XYSortedField& if (!found) { // the rectangle [pmin,pend] is opaque, fill it out.push_back(pmin); - out.push_back(aiVector2D(pmin.x,pmax.y)); + out.push_back(IfcVector2(pmin.x,pmax.y)); out.push_back(pmax); - out.push_back(aiVector2D(pmax.x,pmin.y)); + out.push_back(IfcVector2(pmax.x,pmin.y)); return; } @@ -943,13 +943,13 @@ void QuadrifyPart(const aiVector2D& pmin, const aiVector2D& pmax, XYSortedField& // 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(aiVector2D(pmin.x,pmax.y)); - out.push_back(aiVector2D(xs,pmax.y)); - out.push_back(aiVector2D(xs,pmin.y)); + 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 - float ylast = pmin.y; + IfcFloat ylast = pmin.y; found = false; for(; start != field.end(); ++start) { const BoundingBox& bb = bbs[(*start).second]; @@ -960,47 +960,47 @@ void QuadrifyPart(const aiVector2D& pmin, const aiVector2D& pmax, XYSortedField& if (bb.second.y > ylast) { found = true; - const float ys = std::max(bb.first.y,pmin.y), ye = std::min(bb.second.y,pmax.y); + const IfcFloat ys = std::max(bb.first.y,pmin.y), ye = std::min(bb.second.y,pmax.y); if (ys - ylast) { - QuadrifyPart( aiVector2D(xs,ylast), aiVector2D(xe,ys) ,field,bbs,out); + QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,ys) ,field,bbs,out); } // the following are the window vertices - /*wnd.push_back(aiVector2D(xs,ys)); - wnd.push_back(aiVector2D(xs,ye)); - wnd.push_back(aiVector2D(xe,ye)); - wnd.push_back(aiVector2D(xe,ys));*/ + /*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(aiVector2D(xs,pmin.y)); - out.push_back(aiVector2D(xs,pmax.y)); - out.push_back(aiVector2D(xe,pmax.y)); - out.push_back(aiVector2D(xe,pmin.y)); + 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( aiVector2D(xs,ylast), aiVector2D(xe,pmax.y) ,field,bbs,out); + QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,pmax.y) ,field,bbs,out); } // now for the whole rest if (pmax.x-xe) { - QuadrifyPart(aiVector2D(xe,pmin.y), pmax ,field,bbs,out); + QuadrifyPart(IfcVector2(xe,pmin.y), pmax ,field,bbs,out); } } // ------------------------------------------------------------------------------------------------ void InsertWindowContours(const std::vector< BoundingBox >& bbs, - const std::vector< std::vector >& contours, + const std::vector< std::vector >& contours, const std::vector& openings, - const std::vector& nors, - const aiMatrix3x3& minv, - const aiVector2D& scale, - const aiVector2D& offset, - float coord, + const std::vector& nors, + const IfcMatrix3& minv, + const IfcVector2& scale, + const IfcVector2& offset, + IfcFloat coord, TempMesh& curmesh) { ai_assert(contours.size() == bbs.size()); @@ -1008,29 +1008,29 @@ void InsertWindowContours(const std::vector< BoundingBox >& bbs, // 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 = bbs[i]; - const std::vector& contour = contours[i]; + const std::vector& contour = contours[i]; // 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 verts; + std::set verts; for(size_t n = 0; n < 4; ++n) { verts.insert(contour[n]); } - const std::set::const_iterator end = verts.end(); + const std::set::const_iterator end = verts.end(); if (verts.find(bb.first)!=end && verts.find(bb.second)!=end - && verts.find(aiVector2D(bb.first.x,bb.second.y))!=end - && verts.find(aiVector2D(bb.second.x,bb.first.y))!=end + && verts.find(IfcVector2(bb.first.x,bb.second.y))!=end + && verts.find(IfcVector2(bb.second.x,bb.first.y))!=end ) { continue; } } - const float epsilon = (bb.first-bb.second).Length()/1000.f; + const IfcFloat epsilon = (bb.first-bb.second).Length()/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; - aiVector2D edge; + IfcVector2 edge; for(size_t n = 0, e=0, size = contour.size();; n=(n+1)%size, ++e) { // sanity checking @@ -1039,7 +1039,7 @@ void InsertWindowContours(const std::vector< BoundingBox >& bbs, break; } - const aiVector2D& v = contour[n]; + const IfcVector2& v = contour[n]; bool hit = false; if (fabs(v.x-bb.first.x)& bbs, 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) { - const aiVector3D v3 = minv * aiVector3D(offset.x + contour[a].x * scale.x, offset.y + contour[a].y * scale.y,coord); + const IfcVector3 v3 = minv * IfcVector3(offset.x + contour[a].x * scale.x, offset.y + contour[a].y * scale.y,coord); curmesh.verts.push_back(v3); } if (edge != contour[last_hit]) { - aiVector2D corner = edge; + IfcVector2 corner = edge; if (fabs(contour[last_hit].x-bb.first.x)& bbs, corner.y = bb.second.y; } - const aiVector3D v3 = minv * aiVector3D(offset.x + corner.x * scale.x, offset.y + corner.y * scale.y,coord); + const IfcVector3 v3 = minv * IfcVector3(offset.x + corner.x * scale.x, offset.y + corner.y * scale.y,coord); curmesh.verts.push_back(v3); } else if (cnt == 1) { @@ -1115,27 +1115,27 @@ void InsertWindowContours(const std::vector< BoundingBox >& bbs, } // ------------------------------------------------------------------------------------------------ -bool TryAddOpenings_Quadrulate(const std::vector& openings,const std::vector& nors, TempMesh& curmesh) +bool TryAddOpenings_Quadrulate(const std::vector& openings,const std::vector& nors, TempMesh& curmesh) { - std::vector& out = curmesh.verts; + std::vector& out = curmesh.verts; // Try to derive a solid base plane within the current surface for use as // working coordinate system. - const aiMatrix3x3& m = DerivePlaneCoordinateSpace(curmesh); - const aiMatrix3x3 minv = aiMatrix3x3(m).Inverse(); - const aiVector3D& nor = aiVector3D(m.c1, m.c2, m.c3); + const IfcMatrix3& m = DerivePlaneCoordinateSpace(curmesh); + const IfcMatrix3 minv = IfcMatrix3(m).Inverse(); + const IfcVector3& nor = IfcVector3(m.c1, m.c2, m.c3); - float coord = -1; + IfcFloat coord = -1; - std::vector contour_flat; + std::vector contour_flat; contour_flat.reserve(out.size()); - aiVector2D vmin, vmax; - MinMaxChooser()(vmin, vmax); + IfcVector2 vmin, vmax; + MinMaxChooser()(vmin, vmax); // Move all points into the new coordinate system, collecting min/max verts on the way - BOOST_FOREACH(aiVector3D& x, out) { - const aiVector3D vv = m * x; + BOOST_FOREACH(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 @@ -1149,10 +1149,10 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st // } coord = vv.z; - vmin = std::min(aiVector2D(vv.x, vv.y), vmin); - vmax = std::max(aiVector2D(vv.x, vv.y), vmax); + vmin = std::min(IfcVector2(vv.x, vv.y), vmin); + vmax = std::max(IfcVector2(vv.x, vv.y), vmax); - contour_flat.push_back(aiVector2D(vv.x,vv.y)); + contour_flat.push_back(IfcVector2(vv.x,vv.y)); } // With the current code in DerivePlaneCoordinateSpace, @@ -1160,7 +1160,7 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st // but here we won't rely on this. vmax -= vmin; - BOOST_FOREACH(aiVector2D& vv, contour_flat) { + BOOST_FOREACH(IfcVector2& vv, contour_flat) { vv.x = (vv.x - vmin.x) / vmax.x; vv.y = (vv.y - vmin.y) / vmax.y; } @@ -1170,31 +1170,31 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st std::vector< BoundingBox > bbs; XYSortedField field; - std::vector< std::vector > contours; + std::vector< std::vector > contours; size_t c = 0; BOOST_FOREACH(const TempOpening& t,openings) { - const aiVector3D& outernor = nors[c++]; - const float dot = nor * outernor; + const IfcVector3& outernor = nors[c++]; + const IfcFloat dot = nor * outernor; if (fabs(dot)<1.f-1e-6f) { continue; } - const std::vector& va = t.profileMesh->verts; + const std::vector& va = t.profileMesh->verts; if(va.size() <= 2) { continue; } - aiVector2D vpmin,vpmax; - MinMaxChooser()(vpmin,vpmax); + IfcVector2 vpmin,vpmax; + MinMaxChooser()(vpmin,vpmax); - contours.push_back(std::vector()); - std::vector& contour = contours.back(); + contours.push_back(std::vector()); + std::vector& contour = contours.back(); - BOOST_FOREACH(const aiVector3D& x, t.profileMesh->verts) { - const aiVector3D v = m * x; + BOOST_FOREACH(const IfcVector3& x, t.profileMesh->verts) { + const IfcVector3 v = m * x; - aiVector2D vv(v.x, v.y); + IfcVector2 vv(v.x, v.y); // rescale vv.x = (vv.x - vmin.x) / vmax.x; @@ -1231,12 +1231,12 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st return false; } - std::vector outflat; + std::vector outflat; outflat.reserve(openings.size()*4); - QuadrifyPart(aiVector2D(0.f,0.f),aiVector2D(1.f,1.f),field,bbs,outflat); + QuadrifyPart(IfcVector2(0.f,0.f),IfcVector2(1.f,1.f),field,bbs,outflat); ai_assert(!(outflat.size() % 4)); - std::vector vold; + std::vector vold; std::vector iold; vold.reserve(outflat.size()); @@ -1251,7 +1251,7 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st ClipperLib::Polygon clip; clip.reserve(contour_flat.size()); - BOOST_FOREACH(const aiVector2D& pip, contour_flat) { + BOOST_FOREACH(const IfcVector2& pip, contour_flat) { clip.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); } @@ -1264,7 +1264,7 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st // previous steps subject.reserve(4); size_t cnt = 0; - BOOST_FOREACH(const aiVector2D& pip, outflat) { + BOOST_FOREACH(const IfcVector2& pip, outflat) { subject.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) )); if (!(++cnt % 4)) { if (!ClipperLib::Orientation(subject)) { @@ -1279,7 +1279,7 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st BOOST_FOREACH(const ClipperLib::ExPolygon& ex, clipped) { iold.push_back(ex.outer.size()); BOOST_FOREACH(const ClipperLib::IntPoint& point, ex.outer) { - vold.push_back( minv * aiVector3D( + vold.push_back( minv * IfcVector3( vmin.x + from_int64_f(point.X) * vmax.x, vmin.y + from_int64_f(point.Y) * vmax.y, coord)); @@ -1300,8 +1300,8 @@ bool TryAddOpenings_Quadrulate(const std::vector& openings,const st iold.resize(outflat.size()/4,4); - BOOST_FOREACH(const aiVector2D& vproj, outflat) { - const aiVector3D v3 = minv * aiVector3D(vmin.x + vproj.x * vmax.x, vmin.y + vproj.y * vmax.y,coord); + BOOST_FOREACH(const IfcVector2& vproj, outflat) { + const IfcVector3 v3 = minv * IfcVector3(vmin.x + vproj.x * vmax.x, vmin.y + vproj.y * vmax.y,coord); vold.push_back(v3); } } @@ -1325,7 +1325,7 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul return; } - aiVector3D dir; + IfcVector3 dir; ConvertDirection(dir,solid.ExtrudedDirection); dir *= solid.Depth; @@ -1334,7 +1334,7 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul // the underlying profile, extrude along the given axis, forming new // triangles. - std::vector& in = meshout.verts; + std::vector& in = meshout.verts; const size_t size=in.size(); const bool has_area = solid.SweptArea->ProfileType == "AREA" && size>2; @@ -1349,16 +1349,16 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul result.vertcnt.reserve(meshout.vertcnt.size()+2); // First step: transform all vertices into the target coordinate space - aiMatrix4x4 trafo; + IfcMatrix4 trafo; ConvertAxisPlacement(trafo, solid.Position); - BOOST_FOREACH(aiVector3D& v,in) { + BOOST_FOREACH(IfcVector3& v,in) { v *= trafo; } - aiVector3D min = in[0]; - dir *= aiMatrix3x3(trafo); + IfcVector3 min = in[0]; + dir *= IfcMatrix3(trafo); - std::vector nors; + std::vector nors; const bool openings = !!conv.apply_openings && conv.apply_openings->size(); // Compute the normal vectors for all opening polygons as a prerequisite @@ -1378,7 +1378,7 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul TempMesh& bounds = *t.profileMesh.get(); if (bounds.verts.size() <= 2) { - nors.push_back(aiVector3D()); + nors.push_back(IfcVector3()); continue; } nors.push_back(((bounds.verts[2]-bounds.verts[0])^(bounds.verts[1]-bounds.verts[0]) ).Normalize()); @@ -1388,7 +1388,7 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul TempMesh temp; TempMesh& curmesh = openings ? temp : result; - std::vector& out = curmesh.verts; + std::vector& out = curmesh.verts; size_t sides_with_openings = 0; for(size_t i = 0; i < size; ++i) { @@ -1416,7 +1416,7 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul for(size_t n = 0; n < 2; ++n) { for(size_t i = size; i--; ) { - out.push_back(in[i]+(n?dir:aiVector3D())); + out.push_back(in[i]+(n?dir:IfcVector3())); } curmesh.vertcnt.push_back(size); @@ -1451,13 +1451,13 @@ void ProcessSweptAreaSolid(const IfcSweptAreaSolid& swept, TempMesh& meshout, Co boost::shared_ptr meshtmp(new TempMesh()); ProcessProfile(swept.SweptArea,*meshtmp,conv); - aiMatrix4x4 m; + IfcMatrix4 m; ConvertAxisPlacement(m,solid->Position); meshtmp->Transform(m); - aiVector3D dir; + IfcVector3 dir; ConvertDirection(dir,solid->ExtrudedDirection); - conv.collect_openings->push_back(TempOpening(solid, aiMatrix3x3(m) * (dir*solid->Depth),meshtmp)); + conv.collect_openings->push_back(TempOpening(solid, IfcMatrix3(m) * (dir*solid->Depth),meshtmp)); return; } @@ -1480,16 +1480,16 @@ enum Intersect { }; // ------------------------------------------------------------------------------------------------ -Intersect IntersectSegmentPlane(const aiVector3D& p,const aiVector3D& n, const aiVector3D& e0, const aiVector3D& e1, aiVector3D& out) +Intersect IntersectSegmentPlane(const IfcVector3& p,const IfcVector3& n, const IfcVector3& e0, const IfcVector3& e1, IfcVector3& out) { - const aiVector3D pdelta = e0 - p, seg = e1-e0; - const float dotOne = n*seg, dotTwo = -(n*pdelta); + const IfcVector3 pdelta = e0 - p, seg = e1-e0; + const IfcFloat dotOne = n*seg, dotTwo = -(n*pdelta); if (fabs(dotOne) < 1e-6) { return fabs(dotTwo) < 1e-6f ? Intersect_LiesOnPlane : Intersect_No; } - const float t = dotTwo/dotOne; + const IfcFloat t = dotTwo/dotOne; // t must be in [0..1] if the intersection point is within the given segment if (t > 1.f || t < 0.f) { return Intersect_No; @@ -1532,7 +1532,7 @@ void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, Conversio } // extract plane base position vector and normal vector - aiVector3D p,n(0.f,0.f,1.f); + IfcVector3 p,n(0.f,0.f,1.f); if (plane->Position->Axis) { ConvertDirection(n,plane->Position->Axis.Get()); } @@ -1543,8 +1543,8 @@ void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, Conversio } // clip the current contents of `meshout` against the plane we obtained from the second operand - const std::vector& in = meshout.verts; - std::vector& outvert = result.verts; + const std::vector& in = meshout.verts; + std::vector& outvert = result.verts; std::vector::const_iterator begin=meshout.vertcnt.begin(), end=meshout.vertcnt.end(), iit; outvert.reserve(in.size()); @@ -1555,10 +1555,10 @@ void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, Conversio unsigned int newcount = 0; for(unsigned int i = 0; i < *iit; ++i) { - const aiVector3D& e0 = in[vidx+i], e1 = in[vidx+(i+1)%*iit]; + const IfcVector3& e0 = in[vidx+i], e1 = in[vidx+(i+1)%*iit]; // does the next segment intersect the plane? - aiVector3D isectpos; + IfcVector3 isectpos; const Intersect isect = IntersectSegmentPlane(p,n,e0,e1,isectpos); if (isect == Intersect_No || isect == Intersect_LiesOnPlane) { if ( (e0-p).Normalize()*n > 0 ) { @@ -1585,17 +1585,17 @@ void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, Conversio continue; } - aiVector3D vmin,vmax; + IfcVector3 vmin,vmax; ArrayBounds(&*(outvert.end()-newcount),newcount,vmin,vmax); - // filter our double points - those may happen if a point lies - // directly on the intersection line. However, due to float + // filter our IfcFloat points - those may happen if a point lies + // directly on the intersection line. However, due to IfcFloat // precision a bitwise comparison is not feasible to detect // this case. - const float epsilon = (vmax-vmin).SquareLength() / 1e6f; + const IfcFloat epsilon = (vmax-vmin).SquareLength() / 1e6f; FuzzyVectorCompare fz(epsilon); - std::vector::iterator e = std::unique( outvert.end()-newcount, outvert.end(), fz ); + std::vector::iterator e = std::unique( outvert.end()-newcount, outvert.end(), fz ); if (e != outvert.end()) { newcount -= static_cast(std::distance(e,outvert.end())); outvert.erase(e,outvert.end()); diff --git a/code/IFCLoader.cpp b/code/IFCLoader.cpp index 4af143ef6..472ae11ae 100644 --- a/code/IFCLoader.cpp +++ b/code/IFCLoader.cpp @@ -228,7 +228,7 @@ void IFCImporter::InternReadFile( const std::string& pFile, // apply world coordinate system (which includes the scaling to convert to meters and a -90 degrees rotation around x) aiMatrix4x4 scale, rot; - aiMatrix4x4::Scaling(aiVector3D(conv.len_scale,conv.len_scale,conv.len_scale),scale); + aiMatrix4x4::Scaling(static_cast(IfcVector3(conv.len_scale)),scale); aiMatrix4x4::RotationX(-AI_MATH_HALF_PI_F,rot); pScene->mRootNode->mTransformation = rot * scale * conv.wcs * pScene->mRootNode->mTransformation; @@ -356,10 +356,10 @@ bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector< nd->mName.Set("IfcMappedItem"); // handle the Cartesian operator - aiMatrix4x4 m; + IfcMatrix4 m; ConvertTransformOperator(m, *mapped.MappingTarget); - aiMatrix4x4 msrc; + IfcMatrix4 msrc; ConvertAxisPlacement(msrc,*mapped.MappingSource->MappingOrigin,conv); msrc = m*msrc; @@ -367,7 +367,7 @@ bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector< std::vector meshes; const size_t old_openings = conv.collect_openings ? conv.collect_openings->size() : 0; if (conv.apply_openings) { - aiMatrix4x4 minv = msrc; + IfcMatrix4 minv = msrc; minv.Inverse(); BOOST_FOREACH(TempOpening& open,*conv.apply_openings){ open.Transform(minv); @@ -401,7 +401,7 @@ bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector< } } - nd->mTransformation = nd_src->mTransformation * msrc; + nd->mTransformation = nd_src->mTransformation * static_cast( msrc ); subnodes_src.push_back(nd.release()); return true; @@ -543,7 +543,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion std::vector openings; - aiMatrix4x4 myInv; + IfcMatrix4 myInv; bool didinv = false; // convert everything contained directly within this structure, @@ -733,7 +733,7 @@ void ProcessSpatialStructures(ConversionData& conv) void MakeTreeRelative(aiNode* start, const aiMatrix4x4& combined) { // combined is the parent's absolute transformation matrix - aiMatrix4x4 old = start->mTransformation; + const aiMatrix4x4 old = start->mTransformation; if (!combined.IsIdentity()) { start->mTransformation = aiMatrix4x4(combined).Inverse() * start->mTransformation; @@ -748,7 +748,7 @@ void MakeTreeRelative(aiNode* start, const aiMatrix4x4& combined) // ------------------------------------------------------------------------------------------------ void MakeTreeRelative(ConversionData& conv) { - MakeTreeRelative(conv.out->mRootNode,aiMatrix4x4()); + MakeTreeRelative(conv.out->mRootNode,IfcMatrix4()); } } // !anon diff --git a/code/IFCMaterial.cpp b/code/IFCMaterial.cpp index a507b1bc3..c3bf06a3f 100644 --- a/code/IFCMaterial.cpp +++ b/code/IFCMaterial.cpp @@ -76,7 +76,7 @@ void FillMaterial(aiMaterial* mat,const IFC::IfcSurfaceStyle* surf,ConversionDat // now see which kinds of surface information are present BOOST_FOREACH(boost::shared_ptr< const IFC::IfcSurfaceStyleElementSelect > sel2, surf->Styles) { if (const IFC::IfcSurfaceStyleShading* shade = sel2->ResolveSelectPtr(conv.db)) { - aiColor4D col_base,col; + IfcColor4 col_base,col; ConvertColor(col_base, shade->SurfaceColour); mat->AddProperty(&col_base,1, AI_MATKEY_COLOR_DIFFUSE); @@ -84,7 +84,7 @@ void FillMaterial(aiMaterial* mat,const IFC::IfcSurfaceStyle* surf,ConversionDat if (const IFC::IfcSurfaceStyleRendering* ren = shade->ToPtr()) { if (ren->Transparency) { - const float t = 1.f-ren->Transparency.Get(); + const IfcFloat t = 1.f-ren->Transparency.Get(); mat->AddProperty(&t,1, AI_MATKEY_OPACITY); } @@ -115,7 +115,7 @@ void FillMaterial(aiMaterial* mat,const IFC::IfcSurfaceStyle* surf,ConversionDat if(const EXPRESS::REAL* rt = ren->SpecularHighlight.Get()->ToPtr()) { // at this point we don't distinguish between the two distinct ways of // specifying highlight intensities. leave this to the user. - const float e = *rt; + const IfcFloat e = *rt; mat->AddProperty(&e,1,AI_MATKEY_SHININESS); } else { @@ -141,7 +141,7 @@ unsigned int ProcessMaterials(const IFC::IfcRepresentationItem& item, Conversion name.Set(""); mat->AddProperty(&name,AI_MATKEY_NAME); - aiColor4D col = aiColor4D(0.6f,0.6f,0.6f,1.0f); + IfcColor4 col = IfcColor4(0.6f,0.6f,0.6f,1.0f); mat->AddProperty(&col,1, AI_MATKEY_COLOR_DIFFUSE); conv.materials.push_back(mat.release()); diff --git a/code/IFCProfile.cpp b/code/IFCProfile.cpp index 953e4fcc2..21d7cdf7f 100644 --- a/code/IFCProfile.cpp +++ b/code/IFCProfile.cpp @@ -54,7 +54,7 @@ namespace Assimp { void ProcessPolyLine(const IfcPolyline& def, TempMesh& meshout, ConversionData& /*conv*/) { // this won't produce a valid mesh, it just spits out a list of vertices - aiVector3D t; + IfcVector3 t; BOOST_FOREACH(const IfcCartesianPoint& cp, def.Points) { ConvertCartesianPoint(t,cp); meshout.verts.push_back(t); @@ -104,13 +104,13 @@ void ProcessOpenProfile(const IfcArbitraryOpenProfileDef& def, TempMesh& meshout void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh& meshout, ConversionData& conv) { if(const IfcRectangleProfileDef* const cprofile = def.ToPtr()) { - const float x = cprofile->XDim*0.5f, y = cprofile->YDim*0.5f; + const IfcFloat x = cprofile->XDim*0.5f, y = cprofile->YDim*0.5f; meshout.verts.reserve(meshout.verts.size()+4); - meshout.verts.push_back( aiVector3D( x, y, 0.f )); - meshout.verts.push_back( aiVector3D(-x, y, 0.f )); - meshout.verts.push_back( aiVector3D(-x,-y, 0.f )); - meshout.verts.push_back( aiVector3D( x,-y, 0.f )); + meshout.verts.push_back( IfcVector3( x, y, 0.f )); + meshout.verts.push_back( IfcVector3(-x, y, 0.f )); + meshout.verts.push_back( IfcVector3(-x,-y, 0.f )); + meshout.verts.push_back( IfcVector3( x,-y, 0.f )); meshout.vertcnt.push_back(4); } else if( const IfcCircleProfileDef* const circle = def.ToPtr()) { @@ -118,13 +118,13 @@ void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh& // TODO } const size_t segments = 32; - const float delta = AI_MATH_TWO_PI_F/segments, radius = circle->Radius; + const IfcFloat delta = AI_MATH_TWO_PI_F/segments, radius = circle->Radius; meshout.verts.reserve(segments); - float angle = 0.f; + IfcFloat angle = 0.f; for(size_t i = 0; i < segments; ++i, angle += delta) { - meshout.verts.push_back( aiVector3D( cos(angle)*radius, sin(angle)*radius, 0.f )); + meshout.verts.push_back( IfcVector3( cos(angle)*radius, sin(angle)*radius, 0.f )); } meshout.vertcnt.push_back(segments); @@ -134,7 +134,7 @@ void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh& return; } - aiMatrix4x4 trafo; + IfcMatrix4 trafo; ConvertAxisPlacement(trafo, *def.Position); meshout.Transform(trafo); } diff --git a/code/IFCUtil.cpp b/code/IFCUtil.cpp index cdaaf99ff..9781660bb 100644 --- a/code/IFCUtil.cpp +++ b/code/IFCUtil.cpp @@ -52,12 +52,12 @@ namespace Assimp { namespace IFC { // ------------------------------------------------------------------------------------------------ -void TempOpening::Transform(const aiMatrix4x4& mat) +void TempOpening::Transform(const IfcMatrix4& mat) { if(profileMesh) { profileMesh->Transform(mat); } - extrusionDir *= aiMatrix3x3(mat); + extrusionDir *= IfcMatrix3(mat); } // ------------------------------------------------------------------------------------------------ @@ -107,17 +107,17 @@ void TempMesh::Clear() } // ------------------------------------------------------------------------------------------------ -void TempMesh::Transform(const aiMatrix4x4& mat) +void TempMesh::Transform(const IfcMatrix4& mat) { - BOOST_FOREACH(aiVector3D& v, verts) { + BOOST_FOREACH(IfcVector3& v, verts) { v *= mat; } } // ------------------------------------------------------------------------------ -aiVector3D TempMesh::Center() const +IfcVector3 TempMesh::Center() const { - return std::accumulate(verts.begin(),verts.end(),aiVector3D(0.f,0.f,0.f)) / static_cast(verts.size()); + return std::accumulate(verts.begin(),verts.end(),IfcVector3()) / static_cast(verts.size()); } // ------------------------------------------------------------------------------------------------ @@ -132,32 +132,32 @@ void TempMesh::RemoveAdjacentDuplicates() { bool drop = false; - std::vector::iterator base = verts.begin(); + std::vector::iterator base = verts.begin(); BOOST_FOREACH(unsigned int& cnt, vertcnt) { if (cnt < 2){ base += cnt; continue; } - aiVector3D vmin,vmax; + IfcVector3 vmin,vmax; ArrayBounds(&*base, cnt ,vmin,vmax); - const float epsilon = (vmax-vmin).SquareLength() / 1e9f; - //const float dotepsilon = 1e-9; + const IfcFloat epsilon = (vmax-vmin).SquareLength() / static_cast(1e9); + //const IfcFloat dotepsilon = 1e-9; //// look for vertices that lie directly on the line between their predecessor and their //// successor and replace them with either of them. //for(size_t i = 0; i < cnt; ++i) { - // aiVector3D& v1 = *(base+i), &v0 = *(base+(i?i-1:cnt-1)), &v2 = *(base+(i+1)%cnt); - // const aiVector3D& d0 = (v1-v0), &d1 = (v2-v1); - // const float l0 = d0.SquareLength(), l1 = d1.SquareLength(); + // IfcVector3& v1 = *(base+i), &v0 = *(base+(i?i-1:cnt-1)), &v2 = *(base+(i+1)%cnt); + // const IfcVector3& d0 = (v1-v0), &d1 = (v2-v1); + // const IfcFloat l0 = d0.SquareLength(), l1 = d1.SquareLength(); // if (!l0 || !l1) { // continue; // } - // const float d = (d0/sqrt(l0))*(d1/sqrt(l1)); + // const IfcFloat d = (d0/sqrt(l0))*(d1/sqrt(l1)); // if ( d >= 1.f-dotepsilon ) { // v1 = v0; @@ -171,7 +171,7 @@ void TempMesh::RemoveAdjacentDuplicates() // drop any identical, adjacent vertices. this pass will collect the dropouts // of the previous pass as a side-effect. FuzzyVectorCompare fz(epsilon); - std::vector::iterator end = base+cnt, e = std::unique( base, end, fz ); + std::vector::iterator end = base+cnt, e = std::unique( base, end, fz ); if (e != end) { cnt -= static_cast(std::distance(e, end)); verts.erase(e,end); @@ -200,7 +200,7 @@ bool IsTrue(const EXPRESS::BOOLEAN& in) } // ------------------------------------------------------------------------------------------------ -float ConvertSIPrefix(const std::string& prefix) +IfcFloat ConvertSIPrefix(const std::string& prefix) { if (prefix == "EXA") { return 1e18f; @@ -257,7 +257,7 @@ float ConvertSIPrefix(const std::string& prefix) } // ------------------------------------------------------------------------------------------------ -void ConvertColor(aiColor4D& out, const IfcColourRgb& in) +void ConvertColor(IfcColor4& out, const IfcColourRgb& in) { out.r = in.Red; out.g = in.Green; @@ -266,7 +266,7 @@ void ConvertColor(aiColor4D& out, const IfcColourRgb& in) } // ------------------------------------------------------------------------------------------------ -void ConvertColor(aiColor4D& out, const IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base) +void ConvertColor(IfcColor4& out, const IfcColourOrFactor& in,ConversionData& conv,const IfcColor4* base) { if (const EXPRESS::REAL* const r = in.ToPtr()) { out.r = out.g = out.b = *r; @@ -287,29 +287,29 @@ void ConvertColor(aiColor4D& out, const IfcColourOrFactor& in,ConversionData& co } // ------------------------------------------------------------------------------------------------ -void ConvertCartesianPoint(aiVector3D& out, const IfcCartesianPoint& in) +void ConvertCartesianPoint(IfcVector3& out, const IfcCartesianPoint& in) { - out = aiVector3D(); + out = IfcVector3(); for(size_t i = 0; i < in.Coordinates.size(); ++i) { out[i] = in.Coordinates[i]; } } // ------------------------------------------------------------------------------------------------ -void ConvertVector(aiVector3D& out, const IfcVector& in) +void ConvertVector(IfcVector3& out, const IfcVector& in) { ConvertDirection(out,in.Orientation); out *= in.Magnitude; } // ------------------------------------------------------------------------------------------------ -void ConvertDirection(aiVector3D& out, const IfcDirection& in) +void ConvertDirection(IfcVector3& out, const IfcDirection& in) { - out = aiVector3D(); + out = IfcVector3(); for(size_t i = 0; i < in.DirectionRatios.size(); ++i) { out[i] = in.DirectionRatios[i]; } - const float len = out.Length(); + const IfcFloat len = out.Length(); if (len<1e-6) { IFCImporter::LogWarn("direction vector magnitude too small, normalization would result in a division by zero"); return; @@ -318,7 +318,7 @@ void ConvertDirection(aiVector3D& out, const IfcDirection& in) } // ------------------------------------------------------------------------------------------------ -void AssignMatrixAxes(aiMatrix4x4& out, const aiVector3D& x, const aiVector3D& y, const aiVector3D& z) +void AssignMatrixAxes(IfcMatrix4& out, const IfcVector3& x, const IfcVector3& y, const IfcVector3& z) { out.a1 = x.x; out.b1 = x.y; @@ -334,12 +334,12 @@ void AssignMatrixAxes(aiMatrix4x4& out, const aiVector3D& x, const aiVector3D& y } // ------------------------------------------------------------------------------------------------ -void ConvertAxisPlacement(aiMatrix4x4& out, const IfcAxis2Placement3D& in) +void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement3D& in) { - aiVector3D loc; + IfcVector3 loc; ConvertCartesianPoint(loc,in.Location); - aiVector3D z(0.f,0.f,1.f),r(1.f,0.f,0.f),x; + IfcVector3 z(0.f,0.f,1.f),r(1.f,0.f,0.f),x; if (in.Axis) { ConvertDirection(z,*in.Axis.Get()); @@ -348,47 +348,47 @@ void ConvertAxisPlacement(aiMatrix4x4& out, const IfcAxis2Placement3D& in) ConvertDirection(r,*in.RefDirection.Get()); } - aiVector3D v = r.Normalize(); - aiVector3D tmpx = z * (v*z); + IfcVector3 v = r.Normalize(); + IfcVector3 tmpx = z * (v*z); x = (v-tmpx).Normalize(); - aiVector3D y = (z^x); + IfcVector3 y = (z^x); - aiMatrix4x4::Translation(loc,out); + IfcMatrix4::Translation(loc,out); AssignMatrixAxes(out,x,y,z); } // ------------------------------------------------------------------------------------------------ -void ConvertAxisPlacement(aiMatrix4x4& out, const IfcAxis2Placement2D& in) +void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement2D& in) { - aiVector3D loc; + IfcVector3 loc; ConvertCartesianPoint(loc,in.Location); - aiVector3D x(1.f,0.f,0.f); + IfcVector3 x(1.f,0.f,0.f); if (in.RefDirection) { ConvertDirection(x,*in.RefDirection.Get()); } - const aiVector3D y = aiVector3D(x.y,-x.x,0.f); + const IfcVector3 y = IfcVector3(x.y,-x.x,0.f); - aiMatrix4x4::Translation(loc,out); - AssignMatrixAxes(out,x,y,aiVector3D(0.f,0.f,1.f)); + IfcMatrix4::Translation(loc,out); + AssignMatrixAxes(out,x,y,IfcVector3(0.f,0.f,1.f)); } // ------------------------------------------------------------------------------------------------ -void ConvertAxisPlacement(aiVector3D& axis, aiVector3D& pos, const IfcAxis1Placement& in) +void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const IfcAxis1Placement& in) { ConvertCartesianPoint(pos,in.Location); if (in.Axis) { ConvertDirection(axis,in.Axis.Get()); } else { - axis = aiVector3D(0.f,0.f,1.f); + axis = IfcVector3(0.f,0.f,1.f); } } // ------------------------------------------------------------------------------------------------ -void ConvertAxisPlacement(aiMatrix4x4& out, const IfcAxis2Placement& in, ConversionData& conv) +void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement& in, ConversionData& conv) { if(const IfcAxis2Placement3D* pl3 = in.ResolveSelectPtr(conv.db)) { ConvertAxisPlacement(out,*pl3); @@ -402,12 +402,12 @@ void ConvertAxisPlacement(aiMatrix4x4& out, const IfcAxis2Placement& in, Convers } // ------------------------------------------------------------------------------------------------ -void ConvertTransformOperator(aiMatrix4x4& out, const IfcCartesianTransformationOperator& op) +void ConvertTransformOperator(IfcMatrix4& out, const IfcCartesianTransformationOperator& op) { - aiVector3D loc; + IfcVector3 loc; ConvertCartesianPoint(loc,op.LocalOrigin); - aiVector3D x(1.f,0.f,0.f),y(0.f,1.f,0.f),z(0.f,0.f,1.f); + IfcVector3 x(1.f,0.f,0.f),y(0.f,1.f,0.f),z(0.f,0.f,1.f); if (op.Axis1) { ConvertDirection(x,*op.Axis1.Get()); } @@ -420,24 +420,24 @@ void ConvertTransformOperator(aiMatrix4x4& out, const IfcCartesianTransformation } } - aiMatrix4x4 locm; - aiMatrix4x4::Translation(loc,locm); + IfcMatrix4 locm; + IfcMatrix4::Translation(loc,locm); AssignMatrixAxes(out,x,y,z); - aiVector3D vscale; + IfcVector3 vscale; if (const IfcCartesianTransformationOperator3DnonUniform* nuni = op.ToPtr()) { vscale.x = nuni->Scale?op.Scale.Get():1.f; vscale.y = nuni->Scale2?nuni->Scale2.Get():1.f; vscale.z = nuni->Scale3?nuni->Scale3.Get():1.f; } else { - const float sc = op.Scale?op.Scale.Get():1.f; - vscale = aiVector3D(sc,sc,sc); + const IfcFloat sc = op.Scale?op.Scale.Get():1.f; + vscale = IfcVector3(sc,sc,sc); } - aiMatrix4x4 s; - aiMatrix4x4::Scaling(vscale,s); + IfcMatrix4 s; + IfcMatrix4::Scaling(vscale,s); out = locm * out * s; } diff --git a/code/IFCUtil.h b/code/IFCUtil.h index 92b04d0e1..2a00e3378 100644 --- a/code/IFCUtil.h +++ b/code/IFCUtil.h @@ -51,6 +51,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace Assimp { namespace IFC { + typedef float IfcFloat; + + // IfcFloat-precision math data types + typedef aiVector2t IfcVector2; + typedef aiVector3t IfcVector3; + typedef aiMatrix4x4t IfcMatrix4; + typedef aiMatrix3x3t IfcMatrix3; + typedef aiColor4t IfcColor4; + + // helper for std::for_each to delete all heap-allocated items in a container template struct delete_fun @@ -67,11 +77,11 @@ struct TempMesh; struct TempOpening { const IFC::IfcExtrudedAreaSolid* solid; - aiVector3D extrusionDir; + IfcVector3 extrusionDir; boost::shared_ptr profileMesh; // ------------------------------------------------------------------------------ - TempOpening(const IFC::IfcExtrudedAreaSolid* solid,aiVector3D extrusionDir,boost::shared_ptr profileMesh) + TempOpening(const IFC::IfcExtrudedAreaSolid* solid,IfcVector3 extrusionDir,boost::shared_ptr profileMesh) : solid(solid) , extrusionDir(extrusionDir) , profileMesh(profileMesh) @@ -79,7 +89,7 @@ struct TempOpening } // ------------------------------------------------------------------------------ - void Transform(const aiMatrix4x4& mat); // defined later since TempMesh is not complete yet + void Transform(const IfcMatrix4& mat); // defined later since TempMesh is not complete yet }; @@ -104,14 +114,14 @@ struct ConversionData std::for_each(materials.begin(),materials.end(),delete_fun()); } - float len_scale, angle_scale; + IfcFloat len_scale, angle_scale; bool plane_angle_in_radians; const STEP::DB& db; const IFC::IfcProject& proj; aiScene* out; - aiMatrix4x4 wcs; + IfcMatrix4 wcs; std::vector meshes; std::vector materials; @@ -135,12 +145,12 @@ struct ConversionData // ------------------------------------------------------------------------------------------------ struct FuzzyVectorCompare { - FuzzyVectorCompare(float epsilon) : epsilon(epsilon) {} - bool operator()(const aiVector3D& a, const aiVector3D& b) { + FuzzyVectorCompare(IfcFloat epsilon) : epsilon(epsilon) {} + bool operator()(const IfcVector3& a, const IfcVector3& b) { return fabs((a-b).SquareLength()) < epsilon; } - const float epsilon; + const IfcFloat epsilon; }; @@ -149,14 +159,14 @@ struct FuzzyVectorCompare { // ------------------------------------------------------------------------------------------------ struct TempMesh { - std::vector verts; + std::vector verts; std::vector vertcnt; // utilities aiMesh* ToMesh(); void Clear(); - void Transform(const aiMatrix4x4& mat); - aiVector3D Center() const; + void Transform(const IfcMatrix4& mat); + IfcVector3 Center() const; void Append(const TempMesh& other); void RemoveAdjacentDuplicates(); }; @@ -166,19 +176,19 @@ struct TempMesh // conversion routines for common IFC entities, implemented in IFCUtil.cpp -void ConvertColor(aiColor4D& out, const IfcColourRgb& in); -void ConvertColor(aiColor4D& out, const IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base); -void ConvertCartesianPoint(aiVector3D& out, const IfcCartesianPoint& in); -void ConvertDirection(aiVector3D& out, const IfcDirection& in); -void ConvertVector(aiVector3D& out, const IfcVector& in); -void AssignMatrixAxes(aiMatrix4x4& out, const aiVector3D& x, const aiVector3D& y, const aiVector3D& z); -void ConvertAxisPlacement(aiMatrix4x4& out, const IfcAxis2Placement3D& in); -void ConvertAxisPlacement(aiMatrix4x4& out, const IfcAxis2Placement2D& in); -void ConvertAxisPlacement(aiVector3D& axis, aiVector3D& pos, const IFC::IfcAxis1Placement& in); -void ConvertAxisPlacement(aiMatrix4x4& out, const IfcAxis2Placement& in, ConversionData& conv); -void ConvertTransformOperator(aiMatrix4x4& out, const IfcCartesianTransformationOperator& op); +void ConvertColor(IfcColor4& out, const IfcColourRgb& in); +void ConvertColor(IfcColor4& out, const IfcColourOrFactor& in,ConversionData& conv,const IfcColor4* base); +void ConvertCartesianPoint(IfcVector3& out, const IfcCartesianPoint& in); +void ConvertDirection(IfcVector3& out, const IfcDirection& in); +void ConvertVector(IfcVector3& out, const IfcVector& in); +void AssignMatrixAxes(IfcMatrix4& out, const IfcVector3& x, const IfcVector3& y, const IfcVector3& z); +void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement3D& in); +void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement2D& in); +void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const IFC::IfcAxis1Placement& in); +void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement& in, ConversionData& conv); +void ConvertTransformOperator(IfcMatrix4& out, const IfcCartesianTransformationOperator& op); bool IsTrue(const EXPRESS::BOOLEAN& in); -float ConvertSIPrefix(const std::string& prefix); +IfcFloat ConvertSIPrefix(const std::string& prefix); // IFCProfile.cpp @@ -224,7 +234,7 @@ protected: public: - typedef std::pair ParamRange; + typedef std::pair ParamRange; public: @@ -232,28 +242,28 @@ public: virtual bool IsClosed() const = 0; // evaluate the curve at the given parametric position - virtual aiVector3D Eval(float p) const = 0; + virtual IfcVector3 Eval(IfcFloat p) const = 0; // try to match a point on the curve to a given parameter // for self-intersecting curves, the result is not ambiguous and // it is undefined which parameter is returned. - virtual bool ReverseEval(const aiVector3D& val, float& paramOut) const; + virtual bool ReverseEval(const IfcVector3& val, IfcFloat& paramOut) const; // get the range of the curve (both inclusive). // +inf and -inf are valid return values, the curve is not bounded in such a case. - virtual std::pair GetParametricRange() const = 0; - float GetParametricRangeDelta() const; + virtual std::pair GetParametricRange() const = 0; + IfcFloat GetParametricRangeDelta() const; // estimate the number of sample points that this curve will require - virtual size_t EstimateSampleCount(float start,float end) const; + virtual size_t EstimateSampleCount(IfcFloat start,IfcFloat end) const; // intelligently sample the curve based on the current settings // and append the result to the mesh - virtual void SampleDiscrete(TempMesh& out,float start,float end) const; + virtual void SampleDiscrete(TempMesh& out,IfcFloat start,IfcFloat end) const; #ifdef _DEBUG // check if a particular parameter value lies within the well-defined range - bool InRange(float) const; + bool InRange(IfcFloat) const; #endif public: