HawkMatrix3 HawkQuaternion::GetAsMatrix3 () const { HawkMatrix3 oRotMat; Float fNorm = GetNorm(); Float fScale= (fNorm > 0? 2.0f/fNorm : 0); Float fTx = fScale*X; Float fTy = fScale*Y; Float fTz = fScale*Z; Float fTwx = fTx*W; Float fTwy = fTy*W; Float fTwz = fTz*W; Float fTxx = fTx*X; Float fTxy = fTy*X; Float fTxz = fTz*X; Float fTyy = fTy*Y; Float fTyz = fTz*Y; Float fTzz = fTz*Z; oRotMat[0][0] = 1.0f-(fTyy+fTzz); oRotMat[1][0] = fTxy-fTwz; oRotMat[2][0] = fTxz+fTwy; oRotMat[0][1] = fTxy+fTwz; oRotMat[1][1] = 1.0f-(fTxx+fTzz); oRotMat[2][1] = fTyz-fTwx; oRotMat[0][2] = fTxz-fTwy; oRotMat[1][2] = fTyz+fTwx; oRotMat[2][2] = 1.0f-(fTxx+fTyy); return oRotMat; }
double inpainting::ComputeData(int i, int j) { gradient grad, temp, grad_T; grad.grad_x = 0; grad.grad_y = 0; double result; double magnitude; double max = 0; int x, y; for (y = MAX(j - myWinSize, 0); y <= MIN(j + myWinSize, m_height - 1); ++y) { for (x = MAX(i - myWinSize, 0); x <= MIN(i + myWinSize, m_width - 1); ++x) { if (m_mark[y * m_width + x] >=0) { if (m_mark[y * m_width + x + 1] < 0 || m_mark[y * m_width + x - 1] < 0 || m_mark[(y + 1) * m_width + x] < 0 || m_mark[(y - 1) * m_width + x] < 0) continue; temp = GetGradient(x, y); magnitude = temp.grad_x * temp.grad_x + temp.grad_y * temp.grad_y; if (magnitude > max) { grad.grad_x = temp.grad_x; grad.grad_y = temp.grad_y; max = magnitude; } } } } grad_T.grad_x = grad.grad_y; grad_T.grad_y = -grad.grad_x; norm nn = GetNorm(i, j); result = nn.norm_x * grad_T.grad_x + nn.norm_y * grad_T.grad_y; result /= 255; result = fabs(result); return result; }
void HACD::ComputeEdgeCost(size_t e) { GraphEdge & gE = m_graph.m_edges[e]; long v1 = gE.m_v1; long v2 = gE.m_v2; if (m_graph.m_vertices[v2].m_ancestors.size()>m_graph.m_vertices[v1].m_ancestors.size()) { gE.m_v1 = v2; gE.m_v2 = v1; std::swap(v1, v2); } GraphVertex & gV1 = m_graph.m_vertices[v1]; GraphVertex & gV2 = m_graph.m_vertices[v2]; #ifdef HACD_DEBUG if (v1 == 308 && v2==276) { gV1.m_convexHull->m_mesh.Save("debug1.wrl"); gV2.m_convexHull->m_mesh.Save("debug2.wrl"); } #endif // create the edge's convex-hull ICHull * ch = new ICHull(m_heapManager); (*ch) = (*gV1.m_convexHull); // update distPoints #ifdef HACD_PRECOMPUTE_CHULLS delete gE.m_convexHull; gE.m_convexHull = 0; #endif std::map<long, DPoint> distPoints; for(size_t p = 0; p < gV1.m_distPoints.Size(); ++p) { distPoints[gV1.m_distPoints[p].m_name] = gV1.m_distPoints[p]; } std::map<long, DPoint>::iterator itDP1; for(size_t p = 0; p < gV2.m_distPoints.Size(); ++p) { const DPoint & point = gV2.m_distPoints[p]; itDP1 = distPoints.find(point.m_name); if (itDP1 == distPoints.end()) { DPoint newPoint(point.m_name, 0, false, point.m_distOnly); distPoints.insert(std::pair<long, DPoint>(point.m_name, newPoint)); if ( !point.m_distOnly ) { ch->AddPoint(m_points[point.m_name], point.m_name); } } else { if ( (itDP1->second).m_distOnly && !point.m_distOnly) { (itDP1->second).m_distOnly = false; ch->AddPoint(m_points[point.m_name], point.m_name); } } } ch->SetDistPoints(&distPoints); // create the convex-hull while (ch->Process() == ICHullErrorInconsistent) // if we face problems when constructing the visual-hull. really ugly!!!! { // if (m_callBack) (*m_callBack)("\t Problem with convex-hull construction [HACD::ComputeEdgeCost]\n", 0.0, 0.0, 0); ICHull * chOld = ch; ch = new ICHull(m_heapManager); CircularList<TMMVertex> & verticesCH = chOld->GetMesh().m_vertices; size_t nV = verticesCH.GetSize(); long ptIndex = 0; verticesCH.Next(); // add noise to avoid the problem ptIndex = verticesCH.GetHead()->GetData().m_name; ch->AddPoint(m_points[ptIndex]+ m_scale * 0.0001 * Vec3<Real>(rand() % 10 - 5, rand() % 10 - 5, rand() % 10 - 5), ptIndex); for(size_t v = 1; v < nV; ++v) { ptIndex = verticesCH.GetHead()->GetData().m_name; ch->AddPoint(m_points[ptIndex], ptIndex); verticesCH.Next(); } delete chOld; } #ifdef HACD_DEBUG if (v1 == 438 && v2==468) { const long nPoints = static_cast<long>(m_nPoints); std::map<long, DPoint>::iterator itDP(distPoints.begin()); std::map<long, DPoint>::iterator itDPEnd(distPoints.end()); for(; itDP != itDPEnd; ++itDP) { if (itDP->first >= nPoints) { long pt = itDP->first - nPoints; ch->AddPoint(m_extraDistPoints[pt], itDP->first); } else if (itDP->first >= 0) { long pt = itDP->first; ch->AddPoint(m_points[pt], itDP->first); } else { long pt = -itDP->first-1; ch->AddPoint(m_facePoints[pt], itDP->first); ch->AddPoint(m_facePoints[pt] + 10.0 * m_faceNormals[pt] , itDP->first); } } printf("-***->\n"); ch->m_mesh.Save("debug.wrl"); } #endif double surf = gV1.m_surf + gV2.m_surf; double concavity = 0.0; double surfCH = ch->ComputeArea() / 2.0; double volumeCH = ch->ComputeVolume(); double vol2Surf = volumeCH / surfCH; double concavity_flat = sqrt(fabs(surfCH-surf)); double weightFlat = std::max(0.0, 1.0 - pow(- vol2Surf * 100.0 / (m_scale * m_flatRegionThreshold), 2.0)); // concavity_flat *= std::max(exp(- vol2Surf * 100.0 / (m_scale * m_flatRegionThreshold)) - exp(-1.0), 0.0); concavity_flat *= weightFlat; if(!ch->IsFlat()) { concavity = Concavity(*ch, distPoints); } concavity += concavity_flat; #ifdef HACD_PRECOMPUTE_CHULLS gE.m_convexHull = ch; #else delete ch; #endif // compute boudary edges double perimeter = 0.0; if (m_alpha > 0.0) { std::set<unsigned long long> boudaryEdges1; for(size_t edV1 = 0; edV1 < gV1.m_boudaryEdges.Size(); ++edV1) { boudaryEdges1.insert(gV1.m_boudaryEdges[edV1]); } std::set<unsigned long long> boudaryEdges2; for(size_t edV2 = 0; edV2 < gV2.m_boudaryEdges.Size(); ++edV2) { boudaryEdges2.insert(gV2.m_boudaryEdges[edV2]); } std::set<unsigned long long> boudaryEdges; std::set_symmetric_difference (boudaryEdges1.begin(), boudaryEdges1.end(), boudaryEdges2.begin(), boudaryEdges2.end(), std::inserter( boudaryEdges, boudaryEdges.begin() ) ); std::set<unsigned long long>::const_iterator itBE(boudaryEdges.begin()); std::set<unsigned long long>::const_iterator itBEEnd(boudaryEdges.end()); for(; itBE != itBEEnd; ++itBE) { perimeter += (m_points[static_cast<long>((*itBE) >> 32)] - m_points[static_cast<long>((*itBE) & 0xFFFFFFFFULL)]).GetNorm(); } }
void Quaternion::Identity(){ Div(GetNorm()); }
Quaternion Quaternion::GetInverse(){ Quaternion q(GetConjugate()); q.Div(GetNorm()); return q; }
float Quaternion::GetMagn(){ return sqrt(GetNorm()); }
Bool HawkQuaternion::IsUnit() const { return HawkMath::Abs<Float>(GetNorm() - 1) < HawkMath::FLOAT_DIFF; }
Bool HawkQuaternion::IsZero() const { return GetNorm() < HawkMath::FLOAT_DIFF; }
void HACD::ComputeEdgeCost(size_t e) { GraphEdge & gE = m_graph.m_edges[e]; long v1 = gE.m_v1; long v2 = gE.m_v2; if (m_graph.m_vertices[v2].m_distPoints.size()>m_graph.m_vertices[v1].m_distPoints.size()) { gE.m_v1 = v2; gE.m_v2 = v1; //std::swap<long>(v1, v2); std::swap(v1, v2); } GraphVertex & gV1 = m_graph.m_vertices[v1]; GraphVertex & gV2 = m_graph.m_vertices[v2]; // delete old convex-hull delete gE.m_convexHull; // create the edge's convex-hull ICHull * ch = new ICHull; gE.m_convexHull = ch; (*ch) = (*gV1.m_convexHull); // update distPoints gE.m_distPoints = gV1.m_distPoints; std::map<long, DPoint>::iterator itDP(gV2.m_distPoints.begin()); std::map<long, DPoint>::iterator itDPEnd(gV2.m_distPoints.end()); std::map<long, DPoint>::iterator itDP1; for(; itDP != itDPEnd; ++itDP) { itDP1 = gE.m_distPoints.find(itDP->first); if (itDP1 == gE.m_distPoints.end()) { gE.m_distPoints[itDP->first].m_distOnly = (itDP->second).m_distOnly; if ( !(itDP->second).m_distOnly ) { ch->AddPoint(m_points[itDP->first], itDP->first); } } else { if ( (itDP1->second).m_distOnly && !(itDP->second).m_distOnly) { gE.m_distPoints[itDP->first].m_distOnly = false; ch->AddPoint(m_points[itDP->first], itDP->first); } } } ch->SetDistPoints(&gE.m_distPoints); // create the convex-hull while (ch->Process() == ICHullErrorInconsistent) // if we face problems when constructing the visual-hull. really ugly!!!! { // if (m_callBack) (*m_callBack)("\t Problem with convex-hull construction [HACD::ComputeEdgeCost]\n", 0.0, 0.0, 0); ch = new ICHull; CircularList<TMMVertex> & verticesCH = (gE.m_convexHull)->GetMesh().m_vertices; size_t nV = verticesCH.GetSize(); long ptIndex = 0; verticesCH.Next(); for(size_t v = 1; v < nV; ++v) { ptIndex = verticesCH.GetHead()->GetData().m_name; ch->AddPoint(m_points[ptIndex], ptIndex); verticesCH.Next(); } delete gE.m_convexHull; gE.m_convexHull = ch; } double volume = 0.0; double concavity = 0.0; if (ch->IsFlat()) { bool insideHull; std::map<long, DPoint>::iterator itDP(gE.m_distPoints.begin()); std::map<long, DPoint>::iterator itDPEnd(gE.m_distPoints.end()); for(; itDP != itDPEnd; ++itDP) { if (itDP->first >= 0) { concavity = std::max<double>(concavity, ch->ComputeDistance(itDP->first, m_points[itDP->first], m_normals[itDP->first], insideHull, false)); } } } else { if (m_addNeighboursDistPoints) { // add distance points from adjacent clusters std::set<long> eEdges; std::set_union(gV1.m_edges.begin(), gV1.m_edges.end(), gV2.m_edges.begin(), gV2.m_edges.end(), std::inserter( eEdges, eEdges.begin() ) ); std::set<long>::const_iterator ed(eEdges.begin()); std::set<long>::const_iterator itEnd(eEdges.end()); long a, b, c; for(; ed != itEnd; ++ed) { a = m_graph.m_edges[*ed].m_v1; b = m_graph.m_edges[*ed].m_v2; if ( a != v2 && a != v1) { c = a; } else if ( b != v2 && b != v1) { c = b; } else { c = -1; } if ( c > 0) { GraphVertex & gVC = m_graph.m_vertices[c]; std::map<long, DPoint>::iterator itDP(gVC.m_distPoints.begin()); std::map<long, DPoint>::iterator itDPEnd(gVC.m_distPoints.end()); std::map<long, DPoint>::iterator itDP1; for(; itDP != itDPEnd; ++itDP) { itDP1 = gE.m_distPoints.find(itDP->first); if (itDP1 == gE.m_distPoints.end()) { if (itDP->first >= 0 && itDP1 == gE.m_distPoints.end() && ch->IsInside(m_points[itDP->first])) { gE.m_distPoints[itDP->first].m_distOnly = true; } else if (itDP->first < 0 && ch->IsInside(m_facePoints[-itDP->first-1])) { gE.m_distPoints[itDP->first].m_distOnly = true; } } } } } } concavity = Concavity(*ch, gE.m_distPoints); } // compute boudary edges double perimeter = 0.0; double surf = 1.0; if (m_alpha > 0.0) { gE.m_boudaryEdges.clear(); std::set_symmetric_difference (gV1.m_boudaryEdges.begin(), gV1.m_boudaryEdges.end(), gV2.m_boudaryEdges.begin(), gV2.m_boudaryEdges.end(), std::inserter( gE.m_boudaryEdges, gE.m_boudaryEdges.begin() ) ); std::set<unsigned long long>::const_iterator itBE(gE.m_boudaryEdges.begin()); std::set<unsigned long long>::const_iterator itBEEnd(gE.m_boudaryEdges.end()); for(; itBE != itBEEnd; ++itBE) { perimeter += (m_points[static_cast<long>((*itBE) >> 32)] - m_points[static_cast<long>((*itBE) & 0xFFFFFFFFULL)]).GetNorm(); } surf = gV1.m_surf + gV2.m_surf; }
void Quaternion :: Normalise ( Quaternion & A ) { Multiply ( A, 1.0 / GetNorm ( A ) ); };