Changeset 9235 for trunk/MagicSoft/Mars/mgeom

Timestamp:

01/21/09 14:37:07 (16 years ago)

Author:

tbretz

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars/mgeom

Files:

• MGeomPix.cc (modified) (1 diff)
• MGeomPix.h (modified) (2 diffs)

trunk/MagicSoft/Mars/mgeom/MGeomPix.cc

@@ -240 +240 @@
     return -1;
 }
+
+// ------------------------------------------------------------------------
+//
+// compute the distance of a point (px,py) to the Hexagon center in world
+// coordinates. Return -1 if inside.
+//
+Float_t MGeomPix::DistanceToPrimitive(Float_t px, Float_t py) const
+{
+    //FIXME: Rotation phi missing!
+
+    static Double_t fgCos60 = 0.5;               //TMath::Cos(TMath::DegToRad()*60);
+    static Double_t fgSin60 = TMath::Sqrt(3.)/2; //TMath::Sin(TMath::DegToRad()*60);
+
+    //
+    //  compute the distance of the Point to the center of the Hexagon
+    //
+    //const Double_t dx = px-fX;
+    //const Double_t dy = py-fY;
+
+    TVector2 v(px-fX, py-fY);
+    // FIXME: fPhi or -fPhi?
+    // v = v.Rotate(-fPhi);             // FIXME: Replace with a precalculates sin/cos vector
+
+    const Double_t dx = v.X();
+    const Double_t dy = v.Y();
+
+    const Double_t disthex = TMath::Sqrt(dx*dx + dy*dy);
+
+    //
+    // Now check if point is outside of hexagon; just check x coordinate
+    // in three coordinate systems: the default one, in which two sides of
+    // the hexagon are paralel to the y axis (see camera displays) and two 
+    // more, rotated with respect to that one by +- 60 degrees.
+    //
+
+    if (TMath::Abs(dx) > fD/2.)
+      return disthex;
+
+    const Double_t dx2 = dx*fgCos60 + dy*fgSin60;
+
+    if  (TMath::Abs(dx2) > fD/2.)
+      return disthex;
+
+    const Double_t dx3 = dx*fgCos60 - dy*fgSin60;
+
+    if  (TMath::Abs(dx3) > fD/2.)
+      return disthex;
+
+    return -1;
+}
+
+// ==============================================================================
+/*
+#include <TOrdCollection.h>
+#include "MMath.h" 
+#include "../mgui/MHexagon.h" // MHexagon::fgDx
+
+// ------------------------------------------------------------------------
+//
+// Small helper class to allow fast sorting of TVector2 by angle
+//
+class HVector2 : public TVector2
+{
+    Double_t fAngle;
+public:
+    HVector2() : TVector2()  { }
+    HVector2(const TVector2 &v) : TVector2(v)  { }
+    HVector2(Double_t x, Double_t y) : TVector2 (x, y) { }
+    void CalcAngle() { fAngle = Phi(); }
+    Bool_t IsSortable() const { return kTRUE; }
+    Int_t Compare(const TObject *obj) const { return ((HVector2*)obj)->fAngle>fAngle ? 1 : -1; }
+    Double_t GetAngle() const { return fAngle; }
+};
+
+// ------------------------------------------------------------------------
+//
+// Calculate the edge points of the intersection area of two hexagons.
+// The points are added as TVector2 to the TOrdCollection.
+// The user is responsible of delete the objects.
+//
+void MGeomPix::GetIntersectionBorder(TOrdCollection &col, const MGeomPix &hex) const
+{
+//    if (fPhi!=0)
+//    {
+//        gLog << warn << "MGeomPix::GetIntersectionBorder: Only phi=0 supported yet." << endl;
+//        return;
+//    }
+
+    Bool_t inside0[6], inside1[6];
+
+    HVector2 v0[6];
+    HVector2 v1[6];
+
+    Int_t cnt0=0;
+    Int_t cnt1=0;
+
+    // Calculate teh edges of each hexagon and whether this edge
+    // is inside the other hexgon or not
+    for (int i=0; i<6; i++)
+    {
+        const Double_t x0 = fX+MHexagon::fgDx[i]*fD;
+        const Double_t y0 = fY+MHexagon::fgDy[i]*fD;
+
+        const Double_t x1 = hex.fX+MHexagon::fgDx[i]*hex.fD;
+        const Double_t y1 = hex.fY+MHexagon::fgDy[i]*hex.fD;
+
+        v0[i].Set(x0, y0);
+        v1[i].Set(x1, y1);
+
+        inside0[i] = hex.DistanceToPrimitive(x0, y0) < 0;
+        inside1[i] = DistanceToPrimitive(x1, y1)     < 0;
+
+        if (inside0[i])
+        {
+            col.Add(new HVector2(v0[i]));
+            cnt0++;
+        }
+        if (inside1[i])
+        {
+            col.Add(new HVector2(v1[i]));
+            cnt1++;
+        }
+    }
+
+    if (cnt0==0 || cnt1==0)
+        return;
+
+    // No calculate which vorder lines intersect
+    Bool_t iscross0[6], iscross1[6];
+    for (int i=0; i<6; i++)
+    {
+        iscross0[i] = (inside0[i] && !inside0[(i+1)%6]) || (!inside0[i] && inside0[(i+1)%6]);
+        iscross1[i] = (inside1[i] && !inside1[(i+1)%6]) || (!inside1[i] && inside1[(i+1)%6]);
+    }
+
+    // Calculate the border points of our intersection area
+    for (int i=0; i<6; i++)
+    {
+        // Skip non intersecting lines
+        if (!iscross0[i])
+            continue;
+
+        for (int j=0; j<6; j++)
+        {
+            // Skip non intersecting lines
+            if (!iscross1[j])
+                continue;
+
+            const TVector2 p = MMath::GetIntersectionPoint(v0[i], v0[(i+1)%6], v1[j], v1[(j+1)%6]);
+            if (hex.DistanceToPrimitive(p.X(), p.Y())<1e-9)
+                col.Add(new HVector2(p));
+        }
+    }
+}
+
+// ------------------------------------------------------------------------
+//
+// Calculate the overlapping area of the two hexagons.
+//
+Double_t MGeomPix::CalcOverlapArea(const MGeomPix &cam) const
+{
+//    if (fPhi!=0)
+//    {
+//        gLog << warn << "MGeomPix::CalcOverlapArea: Only phi=0 supported yet." << endl;
+//        return -1;
+//    }
+
+    TOrdCollection col;
+    col.SetOwner();
+
+    GetIntersectionBorder(col, cam);
+
+    // Check if there is an intersection to proceed with
+    const Int_t n = col.GetEntries();
+    if (n==0)
+        return 0;
+
+    // Calculate the center of gravity
+    TVector2 cog;
+
+    TIter Next(&col);
+    HVector2 *v=0;
+    while ((v=(HVector2*)Next()))
+        cog += *v;
+    cog /= n;
+
+    // Shift the figure to its center-og-gravity and
+    // calculate the angle of the connection line between the
+    // border points of our intersesction area and its cog
+    Next.Reset();
+    while ((v=(HVector2*)Next()))
+    {
+        *v -= cog;
+        v->CalcAngle();
+    }
+
+    // Sort these points by this angle
+    col.Sort();
+
+    // Now sum up the area of all the triangles between two
+    // following points and the cog.
+    Double_t A = 0;
+    for (int i=0; i<n; i++)
+    {
+        // Vectors from cog to two nearby border points
+        const HVector2 *v1 = (HVector2*)col.At(i);
+        const HVector2 *v2 = (HVector2*)col.At((i+1)%n);
+
+        // Angle between both vectors
+        const Double_t a = fmod(v1->GetAngle()-v2->GetAngle()+TMath::TwoPi(), TMath::TwoPi());
+
+        // Length of both vectors
+        const Double_t d1 = v1->Mod();
+        const Double_t d2 = v2->Mod();
+
+        A += d1*d2/2*sin(a);
+    }
+    return A;
+}
+*/
+

trunk/MagicSoft/Mars/mgeom/MGeomPix.h

@@ -8 +8 @@
 class MGeomCam;
 class TVector2;
+class TOrdCollection;
 
 class MGeomPix : public MParContainer
@@ -96 +97 @@
     Int_t  GetDirection(const MGeomPix &pix) const;
 
+    virtual Float_t DistanceToPrimitive(Float_t px, Float_t py) const;
+    //void GetIntersectionBorder(TOrdCollection &col, const MGeomPix &hex) const;
+    //Double_t CalcOverlapArea(const MGeomPix &cam) const;
+
     ClassDef(MGeomPix, 4) // Geometry class describing the geometry of one pixel
 };