#
# MRegionOpsAlgebra-Testfile
#
# November 2008, M. Hoeger
#

# *
# * Note: Call this testscript as follows:
# * TestRunner --no-tmp -i ../Algebras/MRegionOps/test/mregionops.test
# *

# *
# * Preparing the test database
# *

#restore database berlintest from berlintest;
open database berlintest;

delete mpA;
delete mpB;
delete rA;
delete rB;
delete mrA;
delete mrB;
delete t0A;
delete t0B;
delete t1A;
delete t1B;
delete t0;
delete t1;
delete noSamples;
delete step;
delete samples;
delete tolerance;
delete aIb;
delete bIa;
delete aUb;
delete bUa;
delete aMb;
delete bMa;

delete tripU5;
delete tripU5a;
delete tripU5b;
delete tripU8a;
delete trip1;
delete trip2;
delete line1;
delete line2;
delete region1;
delete region2;

restore tripU5 from '../Algebras/MRegionOps/test/tripU5';
restore tripU5a from '../Algebras/MRegionOps/test/tripU5a';
restore tripU5b from '../Algebras/MRegionOps/test/tripU5b';
restore tripU8a from '../Algebras/MRegionOps/test/tripU8a';
#restore trip1 from '../Algebras/MRegionOps/test/trip1';
#restore trip2 from '../Algebras/MRegionOps/test/trip2';
restore line1 from '../Algebras/MRegionOps/test/line1';
restore line2 from '../Algebras/MRegionOps/test/line2';
restore region1 from '../Algebras/MRegionOps/test/region1';
restore region2 from '../Algebras/MRegionOps/test/region2';


#setup mregionopstest

# *
# * Create data in the test database
# *

################################################################################

### Testdata

################################################################################

### Create trips with the SimulationAlgebra

query sim_set_event_params( 60.0, 0.0, 0.0, 0.0 );
let trip1 = segments(line1) namedtransformstream[Part] extend[Vmax: 0.07] sim_create_trip[Part,Vmax,[const instant value "2009-09-01"],[const point value (302.2033996582031 -1702.5960876632982)], 0.02 ];
let trip2 = segments(line2) namedtransformstream[Part] extend[Vmax: 0.01] sim_create_trip[Part,Vmax,[const instant value "2009-01-01"],[const point value (700.5922127715812 -1346.0071390955902)], 0.01 ]


### Determine two moving points mpA and mpB:

let mpA = trip1;
let mpB = trip2;
#let mpA = tripU5;
#let mpB = mpA;
#let mpB = tripU8a;

# Not working unfortunatly, since the resulting units have too short intervals...
#let mpA = train1;
#let mpB = train5;

### Determine two regions rA and rB:

let rA = union_new(westhafen rotate[5500.0, 14600.0, 0.0] scale[3.0], westhafen rotate[5500.0, 14600.0, 50.0] scale[3.0]);
let rB = grunewald scale[0.75] translate[19000.0, 39000.0];

#let rA = union_new(westhafen rotate[5500.0, 14600.0, 0.0] scale[3.0], westhafen rotate[5500.0, 14600.0, 50.0] scale[3.0]);
#let rB = union_new(westhafen rotate[5500.0, 14600.0, 30.0] scale[3.0], westhafen rotate[5500.0, 14600.0, 90.0] scale[3.0]);

#let rA = r1 scale[3.5];
#let rB = r2 scale[3.0] rotate[280.0, 180.0, 90.0];


#let rA = grunewald;
#let rA = grunewald translate[0.0, -2000.0];
#let rA = westhafen;
#let rA = westhafen rotate[5500.0, 14600.0, 50.0];
#let rA = union_new(westhafen rotate[5500.0, 14600.0, 0.0] scale[30.0], westhafen rotate[5500.0, 14600.0, 50.0] scale[30.0]);



#let rB = grunewald;

#let rB = westhafen scale[10.0] translate[-55500.0, -142500.0];
#let rB = grunewald rotate[-1500.0, 7000.0, 60.0];
#let rB = union_new(westhafen rotate[5500.0, 14600.0, 30.0] scale[30.0], westhafen rotate[5500.0, 14600.0, 90.0] scale[30.0]);


### Determine the number of samples to test the result:

let noSamples = 100.0;

################################################################################

let mrA = move(mpA, rA);
let mrB = move(mpB, rB);

let t0A = instant2real(inst(initial(mpA)));
let t0B = instant2real(inst(initial(mpB)));
let t1A = instant2real(inst(final(mpA)));
let t1B = instant2real(inst(final(mpB)));

let t0 = ifthenelse(t0A < t0B, t0A, t0B);
let t1 = ifthenelse(t1A > t1B, t1A, t1B);

let step = (abs(t1 - t0)) / noSamples;

let samples = realstream(t0, t1, step) 
              use[fun(t: real) create_instant(t)] transformstream consume;

let tolerance = 0.1;

# ***********************************************************
# * intersection
# ***********************************************************

#testcase mrA intersection mrB

#yields ()

let aIb = intersection(mrA, mrB);

#yields (bool TRUE)

query samples feed transformstream 
use[ fun(t: instant) 
abs( 
area(val(aIb atinstant t)) 
- 
area(intersection_new(val(mrA atinstant t), val(mrB atinstant t)))
)]
 transformstream max[elem] < tolerance;

# ***********************************************************

#testcase mrB intersection mrA

#yields ()

let bIa = intersection(mrB, mrA);

#yields (bool TRUE)

query samples feed transformstream 
use[ fun(t: instant) 
abs( 
area(val(bIa atinstant t)) 
- 
area(intersection_new(val(mrB atinstant t), val(mrA atinstant t)))
)]
 transformstream max[elem] < tolerance;

# ***********************************************************
# * union
# ***********************************************************

#testcase mrA union mrB

#yields ()

let aUb = mrA union mrB;

#yields (bool TRUE)

query samples feed transformstream 
use[ fun(t: instant) 
abs( 
area(val(aUb atinstant t)) 
- 
area(union_new(val(mrA atinstant t), val(mrB atinstant t)))
)]
 transformstream max[elem] < tolerance;

# ***********************************************************

#testcase mrB union mrA

#yields ()

let bUa = mrB union mrA;

#yields (bool TRUE)

query samples feed transformstream 
use[ fun(t: instant) 
abs( 
area(val(bUa atinstant t)) 
- 
area(union_new(val(mrB atinstant t), val(mrA atinstant t)))
)]
 transformstream max[elem] < tolerance;

# ***********************************************************
# * minus
# ***********************************************************

#testcase mrA minus mrB

#yields ()

let aMb = mrA minus mrB;

#yields (bool TRUE)

query samples feed transformstream 
use[ fun(t: instant) 
abs( 
area(val(aMb atinstant t)) 
- 
area(minus_new(val(mrA atinstant t), val(mrB atinstant t)))
)]
 transformstream max[elem] < tolerance;

# ***********************************************************

#testcase mrB minus mrA

#yields ()

let bMa = mrB minus mrA;

#yields (bool TRUE)

query samples feed transformstream 
use[ fun(t: instant) 
abs( 
area(val(bMa atinstant t)) 
- 
area(minus_new(val(mrB atinstant t), val(mrA atinstant t)))
)]
 transformstream max[elem] < tolerance;

# ***********************************************************

#teardown

#delete mpA;
#delete mpB;
#delete rA;
#delete rB;
#delete mrA;
#delete mrB;
#delete t0A;
#delete t0B;
#delete t1A;
#delete t1B;
#delete t0;
#delete t1;
#delete noSamples;
#delete step;
#delete samples;
#delete tolerance;
#delete aIb;
#delete bIa;
#delete aUb;
#delete bUa;
#delete aMb;
#delete bMa;

#delete tripU5;
#delete tripU5a;
#delete tripU5b;
#delete tripU8a;

close database;