#include<bits/stdc++.h>
using namespace std;

typedef long double db;

const db pi=acos(db(-1));

const db eps0=1e-18;
int sgn0(db x)
{
    if(x>eps0)return 1;
    if(x<-eps0)return -1;
    return 0;
}

const db eps1=1e-12;
int sgn1(db x)
{
    if(x>eps1)return 1;
    if(x<-eps1)return -1;
    return 0;
}

struct Point
{
    db x,y;
    Point() {}
    Point(db _x,db _y):x(_x),y(_y) {}
    Point operator + (const Point& t)const
    {
        return Point(x+t.x,y+t.y);
    }
    Point operator - (const Point& t)const
    {
        return Point(x-t.x,y-t.y);
    }
    Point operator * (const db& t)const
    {
        return Point(x*t,y*t);
    }
    Point operator / (const db& t)const
    {
        return Point(x/t,y/t);
    }
    db operator ^ (const Point& t)const
    {
        return x*t.x+y*t.y;
    }
    db len()const
    {
        return sqrt(x*x+y*y);
    }
    db ang()const
    {
        return atan2(y,x);
    }
};

struct Integrate
{
    db chx[2],shx[2],cx[2],sx[2],lgr[2];
    Integrate(db l,db r)
    {
        db t[2]= {l,r};
        for(int i=0; i<2; i++)
        {
            chx[i]=cos(t[i]/2);
            shx[i]=sin(t[i]/2);
            cx[i]=cos(t[i]);
            sx[i]=sin(t[i]);
            lgr[i]=log(abs((chx[i]+shx[i])/(chx[i]-shx[i])));
        }
    }
    db int_1(int s)const // \int_l^r (sinx)^s/(cosx)^(s-1) dx
    {
        if(s==0)return sx[1]-sx[0];
        if(s==1)return -cx[1]+cx[0];
        if(s==2)return (-sx[1]+lgr[1])-(-sx[0]+lgr[0]);
        if(s==3)return (cx[1]+1/cx[1])-(cx[0]+1/cx[0]);
        return NAN;
    }
    db int_1(int n,db *p)const // \int_l^r \prod_{i=1}^{n} cos(x-a_i) / (cosx)^{n-1} dx
    {
        db res=0;
        for(int i=0; i<=n; i++)
            if(sgn0(p[i]))res+=p[i]*int_1(n-i);
        return res;
    }
};

struct Integrate2
{
    db ca,sa,tta[3],tra[3],rra[3];
    Integrate intgr_0,intgr_a;
    Integrate2(db a,db l,db r):intgr_0(l,r),intgr_a(l-a,r-a)
    {
        ca=cos(a),sa=sin(a);
        db ta[2]={-sa,ca},ra[2]={ca,sa};
        for(int i=0;i<3;i++)
            tta[i]=tra[i]=rra[i]=0;
        for(int i=0;i<2;i++)
            for(int j=0;j<2;j++)
            {
                tta[i+j]+=ta[i]*ta[j];
                tra[i+j]+=ta[i]*ra[j];
                rra[i+j]+=ra[i]*ra[j];
            }
    }
    db int_2(int s) // \int_l^r (sinx)^s/((cosx)^(s-2)*cos(x-a)) dx
    {
        if(s==0)return intgr_a.int_1(2,tta);
        if(s==1)return intgr_a.int_1(2,tra);
        if(s==2)return intgr_a.int_1(2,rra);
        if(s==3)
        {
            db res=intgr_0.int_1(2);
            if(sgn0(ca))res-=ca*intgr_a.int_1(2,rra);
            return res/sa;
        }
        return NAN;
    }
    db int_2(int n,db *p) // \int_l^r \prod_{i=1}^{n} cos(x-a_i) / ((cosx)^{n-2}*cos(x-a)) dx
    {
        if(!sgn0(sa))return intgr_0.int_1(n,p)/ca;
        db res=0;
        for(int i=0; i<=n; i++)
            if(sgn0(p[i]))res+=p[i]*int_2(n-i);
        return res;
    }
};

db cal_disjoint(Point s[4],db l,db r)
{
    Point mid=(s[0]+s[1])/2-(s[2]+s[3])/2;
    db res=mid.x*(sin(r)-sin(l))+mid.y*(-cos(r)+cos(l));
    return abs(res);
}

db cal_contain(Point s[4],db l,db r)
{
    swap(s[0],s[2]),swap(s[1],s[3]);
    Point mid=(s[0]+s[1])/2-(s[2]+s[3])/2;
    db all=mid.x*(sin(r)-sin(l))+mid.y*(-cos(r)+cos(l));
    db ang0=(s[3]-s[2]).ang();
    l-=ang0,r-=ang0;
    db ang1=(s[0]-s[2]).ang()-ang0;
    db ang2=(s[1]-s[2]).ang()-ang0;
    db angx=(s[1]-s[0]).ang()-ang0;
    // db angy=(s[2]-s[3]).ang()-ang0; // pi
    // db angc=(s[0]-s[2]).ang()-ang0; // ang1
    db cof1=(s[0]-s[2]).len()/(s[3]-s[2]).len();
    db cof2=(s[1]-s[2]).len()/(s[3]-s[2]).len();
    db a1[2]={sin(ang1),cos(ang1)},a2[2]={sin(ang2),cos(ang2)},ax[2]={sin(angx),cos(angx)};
    db a1x[3]={},a2x[3]={},a11[3]={},a12[3]={},a22[3]={};
    for(int i=0;i<2;i++)
        for(int j=0;j<2;j++)
        {
            a1x[i+j]+=a1[i]*ax[j];
            a2x[i+j]+=a2[i]*ax[j];
            a11[i+j]+=a1[i]*a1[j];
            a12[i+j]+=a1[i]*a2[j];
            a22[i+j]+=a2[i]*a2[j];
        }
    Integrate intgr(l,r);
    db res=(intgr.int_1(2,a1x)*cof1+intgr.int_1(2,a2x)*cof2*2)/6*(s[1]-s[0]).len();
    res-=(intgr.int_1(2,a11)*cof1*cof1+intgr.int_1(2,a12)*cof1*cof2+intgr.int_1(2,a22)*cof2*cof2)/6*(s[2]-s[3]).len();
    res+=(intgr.int_1(2,a11)*cof1+intgr.int_1(2,a12)*cof2)/2*(s[0]-s[2]).len();
    return abs(all-2*res);
}

db cal_intersect(Point s[4],db l,db r)
{
    swap(s[0],s[1]);
    Point mid=(s[0]+s[1])/2-(s[2]+s[3])/2;
    db all=mid.x*(sin(r)-sin(l))+mid.y*(-cos(r)+cos(l));
    db ang1=(s[1]-s[0]).ang();
    l-=ang1,r-=ang1;
    db ang0=(s[2]-s[0]).ang()-ang1;
    db ang2=(s[2]-s[3]).ang()-ang1;
    // db angx=(s[1]-s[0]).ang()-ang1; // 0
    // db angy=(s[2]-s[3]).ang()-ang1; // ang2
    // db angc=(s[0]-s[2]).ang()-ang1; // ang0+pi
    db cof1=(s[2]-s[0]).len()/(s[1]-s[0]).len();
    db cof2=(s[2]-s[0]).len()/(s[2]-s[3]).len();
    db cof=cof1*cof1*cof2/6*(s[1]-s[0]).len()+cof1*cof2*cof2/6*(s[2]-s[3]).len()-cof1*cof2/2*(s[0]-s[2]).len();
    db a0[2]={sin(ang0),cos(ang0)},at0[4]={};
    for(int i=0;i<2;i++)
        for(int j=0;j<2;j++)
            for(int k=0;k<2;k++)
                at0[i+j+k]+=a0[i]*a0[j]*a0[k];
    db res=cof*Integrate2(ang2,l,r).int_2(3,at0);
    return abs(all-2*res);
}

db cal(Point s[4],db l,db r)
{
    db m=(l+r)/2;
    Point d=Point(cos(m),sin(m));
    db l1=s[0]^d,r1=s[1]^d,l2=s[2]^d,r2=s[3]^d;
    if(l1>r1)swap(l1,r1),swap(s[0],s[1]);
    if(l2>r2)swap(l2,r2),swap(s[2],s[3]);
    if(l1>l2 || (l1==l2 && r1<r2))
        swap(l1,l2),swap(r1,r2),swap(s[0],s[2]),swap(s[1],s[3]);
    if(sgn1(r1-l2)<=0)return cal_disjoint(s,l,r);
    if(sgn1(r1-r2)>=0)return cal_contain(s,l,r);
    return cal_intersect(s,l,r);
}

int solve()
{
    Point s[4];
    for(int i=0; i<4; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        s[i]=Point(x,y);
    }
    vector<db> cut{0,pi};
    for(int i=0; i<4; i++)
        for(int j=i+1; j<4; j++)
        {
            if(!sgn1((s[i]-s[j]).len()))continue;
            db t=(s[i]-s[j]).ang()+pi/2;
            while(t<0)t+=pi;
            while(t>=pi)t-=pi;
            cut.push_back(t);
        }
    sort(cut.begin(),cut.end());
    cut.erase(unique(cut.begin(),cut.end()),cut.end());
    db res=0;
    for(size_t i=0; i+1<cut.size(); i++)
        res+=cal(s,cut[i],cut[i+1]);
    return 0*printf("%.18Lf\n",res/2);
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)solve();
    return 0;
}