← Back to branch summary

~ubuntu-branches/ubuntu/maverick/freecad/maverick

« back to all changes in this revision

Viewing changes to src/Mod/Mesh/App/WildMagic4/Wm4Query2TInteger.inl

  • Committer: Bazaar Package Importer
  • Author(s): Teemu Ikonen
  • Date: 2009-07-16 18:37:41 UTC
  • Revision ID: james.westby@ubuntu.com-20090716183741-oww9kcxqrk991i1n
Tags: upstream-0.8.2237
Import upstream version 0.8.2237

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Mod/Mesh/App/WildMagic4/Wm4Query2TInteger.inl
 
1
// Wild Magic Source Code
 
2
// David Eberly
 
3
// http://www.geometrictools.com
 
4
// Copyright (c) 1998-2007
 
5
//
 
6
// This library is free software; you can redistribute it and/or modify it
 
7
// under the terms of the GNU Lesser General Public License as published by
 
8
// the Free Software Foundation; either version 2.1 of the License, or (at
 
9
// your option) any later version.  The license is available for reading at
 
10
// either of the locations:
 
11
//     http://www.gnu.org/copyleft/lgpl.html
 
12
//     http://www.geometrictools.com/License/WildMagicLicense.pdf
 
13
// The license applies to versions 0 through 4 of Wild Magic.
 
14
//
 
15
// Version: 4.0.0 (2006/06/28)
 
16
 
 
17
//----------------------------------------------------------------------------
 
18
template <class Real>
 
19
Query2TInteger<Real>::Query2TInteger (int iVQuantity,
 
20
    const Vector2<Real>* akVertex)
 
21
    :
 
22
    Query2<Real>(iVQuantity,akVertex)
 
23
{
 
24
}
 
25
//----------------------------------------------------------------------------
 
26
template <class Real>
 
27
Query::Type Query2TInteger<Real>::GetType () const
 
28
{
 
29
    return Query::QT_INTEGER;
 
30
}
 
31
//----------------------------------------------------------------------------
 
32
template <class Real>
 
33
int Query2TInteger<Real>::ToLine (const Vector2<Real>& rkP, int iV0, int iV1)
 
34
    const
 
35
{
 
36
    const Vector2<Real>& rkV0 = m_akVertex[iV0];
 
37
    const Vector2<Real>& rkV1 = m_akVertex[iV1];
 
38
 
 
39
    TInteger<2> kX0((int)rkP[0] - (int)rkV0[0]);
 
40
    TInteger<2> kY0((int)rkP[1] - (int)rkV0[1]);
 
41
    TInteger<2> kX1((int)rkV1[0] - (int)rkV0[0]);
 
42
    TInteger<2> kY1((int)rkV1[1] - (int)rkV0[1]);
 
43
 
 
44
    TInteger<2> kDet2 = Det2(kX0,kY0,kX1,kY1);
 
45
    return (kDet2 > 0 ? +1 : (kDet2 < 0 ? -1 : 0));
 
46
}
 
47
//----------------------------------------------------------------------------
 
48
template <class Real>
 
49
int Query2TInteger<Real>::ToCircumcircle (const Vector2<Real>& rkP, int iV0,
 
50
    int iV1, int iV2) const
 
51
{
 
52
    const Vector2<Real>& rkV0 = m_akVertex[iV0];
 
53
    const Vector2<Real>& rkV1 = m_akVertex[iV1];
 
54
    const Vector2<Real>& rkV2 = m_akVertex[iV2];
 
55
 
 
56
    int aiP[2] = { (int)rkP[0], (int)rkP[1] };
 
57
    int aiV0[2] = { (int)rkV0[0], (int)rkV0[1] };
 
58
    int aiV1[2] = { (int)rkV1[0], (int)rkV1[1] };
 
59
    int aiV2[2] = { (int)rkV2[0], (int)rkV2[1] };
 
60
 
 
61
    TInteger<4> kS0x(aiV0[0] + aiP[0]);
 
62
    TInteger<4> kD0x(aiV0[0] - aiP[0]);
 
63
    TInteger<4> kS0y(aiV0[1] + aiP[1]);
 
64
    TInteger<4> kD0y(aiV0[1] - aiP[1]);
 
65
    TInteger<4> kS1x(aiV1[0] + aiP[0]);
 
66
    TInteger<4> kD1x(aiV1[0] - aiP[0]);
 
67
    TInteger<4> kS1y(aiV1[1] + aiP[1]);
 
68
    TInteger<4> kD1y(aiV1[1] - aiP[1]);
 
69
    TInteger<4> kS2x(aiV2[0] + aiP[0]);
 
70
    TInteger<4> kD2x(aiV2[0] - aiP[0]);
 
71
    TInteger<4> kS2y(aiV2[1] + aiP[1]);
 
72
    TInteger<4> kD2y(aiV2[1] - aiP[1]);
 
73
    TInteger<4> kZ0 = kS0x*kD0x + kS0y*kD0y;
 
74
    TInteger<4> kZ1 = kS1x*kD1x + kS1y*kD1y;
 
75
    TInteger<4> kZ2 = kS2x*kD2x + kS2y*kD2y;
 
76
    TInteger<4> kDet3 = Det3(kD0x,kD0y,kZ0,kD1x,kD1y,kZ1,kD2x,kD2y,kZ2);
 
77
    return (kDet3 < 0 ? 1 : (kDet3 > 0 ? -1 : 0));
 
78
}
 
79
//----------------------------------------------------------------------------
 
80
template <class Real>
 
81
TInteger<2> Query2TInteger<Real>::Dot (TInteger<2>& rkX0, TInteger<2>& rkY0,
 
82
    TInteger<2>& rkX1, TInteger<2>& rkY1)
 
83
{
 
84
    return rkX0*rkX1 + rkY0*rkY1;
 
85
}
 
86
//----------------------------------------------------------------------------
 
87
template <class Real>
 
88
TInteger<2> Query2TInteger<Real>::Det2 (TInteger<2>& rkX0, TInteger<2>& rkY0,
 
89
    TInteger<2>& rkX1, TInteger<2>& rkY1)
 
90
{
 
91
    return rkX0*rkY1 - rkX1*rkY0;
 
92
}
 
93
//----------------------------------------------------------------------------
 
94
template <class Real>
 
95
TInteger<4> Query2TInteger<Real>::Det3 (TInteger<4>& rkX0, TInteger<4>& rkY0,
 
96
    TInteger<4>& rkZ0, TInteger<4>& rkX1, TInteger<4>& rkY1,
 
97
    TInteger<4>& rkZ1, TInteger<4>& rkX2, TInteger<4>& rkY2,
 
98
    TInteger<4>& rkZ2)
 
99
{
 
100
    TInteger<4> kC00 = rkY1*rkZ2 - rkY2*rkZ1;
 
101
    TInteger<4> kC01 = rkY2*rkZ0 - rkY0*rkZ2;
 
102
    TInteger<4> kC02 = rkY0*rkZ1 - rkY1*rkZ0;
 
103
    return rkX0*kC00 + rkX1*kC01 + rkX2*kC02;
 
104
}
 
105
//----------------------------------------------------------------------------