along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/GIS/contour.cpp

2793 lines
85 KiB
C++
Raw Normal View History

firs commit
2026-01-23 17:03:45 +08:00
/*
This file is part of SECONDO.
Copyright (C) 2011, University in Hagen, Department of Computer Science,
Database Systems for New Applications.
SECONDO is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
SECONDO is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with SECONDO; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <algorithm>
#include <stdio.h>
/*
GIS includes
*/
#include "contour.h"
/*
Raster2 and Tile includes
*/
#include "Algebras/Raster2/sint.h"
#include "Algebras/Raster2/sreal.h"
#include "Algebras/Tile/t/tint.h"
#include "Algebras/Tile/t/treal.h"
#include "StopWatch.h"
#include "Algebras/Spatial/DLine.h"
#include "WinUnix.h"
typedef DLine LineType;
using namespace std;
/*
declaration of namespace GISAlgebra
*/
namespace GISAlgebra {
/*
declaration of struct ResultInfo
*/
struct ResultInfo {
ResultInfo(int dummy): level(-32000), cline(0){
}
ResultInfo() {}
int level;
LineType* cline;
};
class ContourLocalInfo{
public:
ContourLocalInfo(const int _num, const double _min,
const int _interval, ListExpr tupleType) :
clines(_num), num(_num),min(_min), interval(_interval){
ResultInfo line(1);
for (int i = 0; i<num; i++) {
clines.Put(i,line);
}
tt = new TupleType(tupleType);
}
~ContourLocalInfo(){
tt->DeleteIfAllowed();
}
void addSegment(int level, const Point& p1, const Point & p2){
HalfSegment hs(true, p1, p2);
// calculate array element
int i = floor((level - min) / interval);
// find correct contour line
ResultInfo temp(1);
clines.Get(i,temp);
// if contour line exists, add segment
if (temp.level != -32000)
{
LineType* line = temp.cline;
int s = line->Size();
hs.attr.edgeno = s/2;
(*line) += hs;
hs.SetLeftDomPoint(false);
(*line) += hs;
}
else
// if not, create new line
{
LineType* line = new LineType(0);
line->StartBulkLoad();
hs.attr.edgeno = 0;
(*line) += hs;
hs.SetLeftDomPoint(false);
(*line) += hs;
int l2 = static_cast<int>(level);
ResultInfo lines(0);
lines.level = l2;
lines.cline = line;
clines.Put(i,lines);
}
}
void finish(){};
Tuple* getNext() {
int i = clines.Size();
if(i<= 0){
return 0;
}
ResultInfo temp(1);
clines.Get(i-1,temp);
clines.resize(i-1);
int j = 2;
while ((temp.level == -32000) && (j <= i)) {
clines.Get(i-j,temp);
clines.resize(i-j);
j++;
}
if ( temp.level == -32000 ) {
return 0;
}
CcInt* level = new CcInt(true,temp.level);
LineType* line = temp.cline;
line->EndBulkLoad();
Tuple* result = new Tuple(tt);
result->PutAttribute(0,level);
result->PutAttribute(1,line);
return result;
}
private:
DbArray<ResultInfo> clines;
int num;
double min;
int interval;
TupleType* tt;
};
/*
1 class ~hSegment~
This class represents a single segment assigned to a height.
There are two spezial values for a normal mark and a specialized
end mark.
*/
class hSegment{
public:
hSegment(){}
hSegment(const int _level, const Point& _p1, const Point& _p2):
level(_level), p1(_p1), p2(_p2){
if(p1.IsDefined() && p2.IsDefined() && (p1< p2)) swap(p1,p2);
}
hSegment(const hSegment& h): level(h.level), p1(h.p1), p2(h.p2){}
~hSegment(){}
hSegment& operator=(const hSegment& h){
level = h.level;
p1 = h.p1;
p2 = h.p2;
return *this;
}
bool operator==(const hSegment& h)const{
return (level==h.level) && AlmostEqual(p1,h.p1) && AlmostEqual(p2,h.p2);
}
bool operator<(const hSegment& h) const{
if(level!=h.level){
return level < h.level;
}
if(!AlmostEqual(p1,h.p1)){
return p1 < h.p1;
}
if(!AlmostEqual(p2,h.p2)){
return p2 < h.p2;
}
return false;
}
inline int getLevel() const{ return level; }
inline const Point& getP1()const{ return p1; }
inline const Point& getP2()const{ return p2; }
static hSegment getEnd(){
return hSegment(0,Point(false,0,0),Point(false,0,0));
}
static hSegment getMarker(){
return hSegment(0,Point(false,0,0),Point(true,0,0));
}
bool isMarker(){
return !p1.IsDefined();
}
bool isEnd(){
return !p1.IsDefined() && !p2.IsDefined();
}
private:
int level;
Point p1;
Point p2;
};
/*
2 class restrictedHeap
This class provides a heap implementation having a restricted size.
The size is given during construction an instance of this class.
When inserting a new element into the heap, the smallest value
(including the new element) is removed from the set of heap elements
and the new element and given back.
*/
template<class T>
class restrictedHeap{
public:
restrictedHeap(size_t slots): slots(slots), used(0){
content = new T[slots];
}
~restrictedHeap(){
delete[] content;
}
/*
Inserts a new element. If the heap overflows, the element's value
is set to the smallest value in the heap (including the element itselfs.
The smallest element is removed from the heap and the result will be true;
*/
bool insert( T& element){
if(used<slots){ // there is space available
content[used] = element;
used++;
climb();
return false;
}
if(element == content[0] || element < content[0]){
return true;
}
std::swap(element,content[0]);
sink();
return true;
}
size_t size() const{
return used;
}
bool empty() const{
return used==0;
}
bool full() const{
return used == slots;
}
const T& getMin(){
assert(used>0);
return content[0];
}
const void deleteMin(){
if(used>0){
swap(content[0], content[used-1]);
used --;
sink();
}
}
private:
size_t slots;
size_t used;
T* content;
/*
lets the last element in the heap climb to its final position
*/
void climb(){
size_t pos = used;
while(pos>1){
size_t father= pos/2;
if(content[father-1] < content[pos-1]){
return;
}
swap(content[father-1], content[pos-1]);
pos = father;
}
}
/*
lets the first element in heap sink to its final position
*/
void sink(){
size_t pos = 1;
while(pos < slots){
size_t s1 = pos*2;
if(s1>used){
return;
}
size_t s2 = s1 + 1;
size_t s;
if(s2>used){
// only one son available
s = s1;
} else {
s = content[s1-1] < content[s2-1]?s1:s2;
}
if(content[pos-1] < content[s-1]){
return; // reached final position
}
swap(content[pos-1],content[s-1]);
pos = s;
}
}
};
/*
3 class segmentStorage
This class provides a storage for hSegment objects.
There are two stages of usage this storage. Within the
first stage, elements can be inserted into this storage.
This stage is finished using the finish() method.
In the second stage (after calling finished), elements
can be retrieved from the storage. The segments are
returned according to its order.
*/
class segmentStorage{
public:
/*
3.1 Contructor
This constructor takes the available memory in bytes as its input.
*/
segmentStorage(size_t mem){
if(mem<4096){
mem = 4096;
}
slots = mem/(sizeof(hSegment) + sizeof(void*) );
if(slots<2){
slots = 2;
}
h1 = new restrictedHeap<hSegment>(slots/2);
h2 = 0;
f1 = 0;
f2 = 0;
outputCache = 0;
buffersize = 8192; // buffersize for file operations
}
/*
3.2 Destructor
*/
~segmentStorage(){
if(h1) delete h1;
if(h2) delete h1;
if(outputCache) delete[] outputCache;
if(f1){ f1->close(); delete f1; }
if(f2){ f2->close(); delete f2; };
for(size_t i=0;i<filenames.size();i++){
remove(filenames[i].c_str());
}
for(size_t i=0;i<filebuffers.size();i++){
delete[] filebuffers[i];
}
}
/*
3.3 insert
This function inserts a new element to this storage.
*/
void insert(hSegment& seg){
if(!h2 && !h1->full()){
// first filling of h1
bool overflow = h1->insert(seg);
assert(!overflow);
return;
}
// stage 2
hSegment cmin = h1->getMin();
h1->deleteMin();
append(f1,cmin); // append to file
if(seg < cmin){
if(!h2){
h2 = new restrictedHeap<hSegment>(slots/2);
}
h2->insert(seg);
} else {
h1->insert(seg);
}
if(h1->size()==0){
appendMarker(f1);
swap(f1,f2);
swap(h1,h2);
}
}
/*
3.4 finish
switch from insertion phase to retrieval phase.
*/
void finish(){
// case 1: h2, f1 and f2 are not present : all items are included in h1
if(h1 && !h2 && !f1 && !f2){
//cout << "Case : all elements are in h1" << endl;
size_t size = h1->size();
if(size>0){
outputCache = new hSegment[size];
int i=0;
while(!h1->empty()){
outputCache[i] = h1->getMin();
i++;
h1->deleteMin();
}
outPos = 0;
outMax = size;
} else {
outPos = 0;
outMax = 0;
}
return;
}
// case 2: h1 and f1 are in use
if(f1 && !h2 && !f2){
// all elements in h1 are greater than those in
// f1, thus we just move the content of h1 to
// the file, generate the output buffer and
// fill the buffer with the content of f1
//cout << "case 2: h1 and f1 are used, h2 and f2 not" << endl;
append(f1,h1,false,true);
outMax = slots;
outputCache = new hSegment[outMax];
f1->seekg(0);
fillOutputCache();
return;
}
// case 3: h1, h2 and f1 is used, f2 not
if(h1 && h2 && f1){
//cout << "case 3 : one or two files and both heaps is used" << endl;
// all elements in f1 are smaller than
// those in h1, elements in h2 are
// smaller than the last element in f1
append(f1,h1,true,true);
append(f2,h2,true,true);
merge(f1,f2);
outputCache = new hSegment[slots];
outMax = slots;
f1->seekg(0);
fillOutputCache();
return;
}
assert(false); // forgotten case
}
/*
3.5 ~hasNext~
Within the retrieval phase, it can be checked whether more elements are available.
*/
bool hasNext() const{
return outPos < outMax;
}
const hSegment& current(){
return outputCache[outPos];
}
void next(){
outPos++;
if(outPos == outMax){
if(f1){
fillOutputCache();
}
}
}
private:
restrictedHeap<hSegment>* h1; // heap
restrictedHeap<hSegment>* h2; // heap
fstream* f1; // file for heap overflow
fstream* f2; // second file
vector<char*> filebuffers; // vector of buffers
size_t slots;
hSegment* outputCache;
size_t outPos;
size_t outMax;
vector<string> filenames;
size_t buffersize;
/*
3.6 append
Appends ~seg~ to ~f~. if ~f~ does not exist, it will be created.
*/
void append(fstream*& f , const hSegment& seg){
if(!f){
string fname = generateFName();
f = new fstream(fname.c_str(), ios_base::in | ios_base::out
| ios_base::binary | ios_base::trunc);
char* buffer = new char[buffersize];
filebuffers.push_back(buffer);
f->rdbuf()->pubsetbuf(buffer, buffersize);
}
f->write((char*) &seg, sizeof(hSegment));
}
/*
3.7 append
Appends a normal marker to the given file.
*/
void appendMarker(fstream*& f){
static hSegment marker = hSegment::getMarker();
append(f,marker);
}
/*
3.8 gerenateFName
Generates a new filename.
*/
string generateFName(){
static int no = 0;
stringstream ss;
ss << "tmp/T_" << WinUnix::getpid() << "_segStorage_" << no;
no++;
filenames.push_back(ss.str());
return ss.str();
}
/*
3.9 fillOutputcache
Copies data from file f1 to the outputcache.
*/
void fillOutputCache(){
assert(f1);
outPos = 0;
size_t pos = 0;
hSegment seg;
while( (pos < outMax) && !f1->eof()){
f1->read((char*)&seg, sizeof(hSegment));
if(!seg.isMarker()){
outputCache[pos] = seg;
pos++;
} else if(seg.isEnd()){
f1->close();
delete f1;
f1 = 0;
outMax = pos;
return;
}
}
if(f1->eof()){
f1->close();
delete f1;
f1 = 0;
}
outMax = pos;
}
/*
3.10 append
Appends all elements within the heap to ~f~. If finishMarker
is set to ~true~, an marker will be appended after the elements
of ~h~. If destroy Heap is set to true, the heap is destroyed
after copying the elements.
*/
void append(fstream*& f,
restrictedHeap<hSegment>*& h,
bool finishMarker, bool destroyHeap){
while(!h->empty()){
append(f,h->getMin());
h->deleteMin();
}
if(finishMarker){
appendMarker(f);
}
if(destroyHeap){
delete h;
h = 0;
}
}
/*
3.11 merge
Merges the contents of f1 and f2 together in result.
The result is written to f1.
*/
void merge(fstream*& f1, fstream*& f2){
StopWatch sw;
size_t phases = 0;
fstream* g1 = new fstream(generateFName().c_str(), ios_base::in |
ios_base::out | ios_base::binary |
ios_base::trunc);
fstream* g2 = new fstream(generateFName().c_str(), ios_base::in |
ios_base::out | ios_base::binary |
ios_base::trunc);
append(f1, hSegment::getEnd());
append(f2, hSegment::getEnd());
char g1buf[buffersize];
char g2buf[buffersize];
g1->rdbuf()->pubsetbuf(g1buf,buffersize);
g2->rdbuf()->pubsetbuf(g2buf,buffersize);
int runs=0;
do{
runs = merge(f1,f2,g1,g2);
swap(f1,g1);
swap(f2,g2);
phases++;
} while(runs > 1);
delete f2;
f2 = 0;
delete g1;
g1 = 0;
delete g2;
g2 = 0;
}
/*
3.12 merge
This function perform a single phase of merging f1 and f2. The merged
runs are written to g1 and g2.
*/
int merge(fstream* f1, fstream* f2, fstream* g1, fstream* g2){
f1->seekg(0);
f2->seekg(0);
g1->seekp(0);
g2->seekp(0);
hSegment f1Cur;
hSegment f2Cur;
int runs = 0;
f1->read((char*) &f1Cur, sizeof(hSegment));
f2->read((char*) &f2Cur, sizeof(hSegment));
while(!f1Cur.isEnd() || !f2Cur.isEnd()){
while(!f1Cur.isMarker() || !f2Cur.isMarker()){
if(f1Cur.isMarker()){
append(g1,f2Cur);
f2->read((char*) &f2Cur, sizeof(hSegment));
} else if(f2Cur.isMarker()){
append(g1,f1Cur);
f1->read((char*) &f1Cur, sizeof(hSegment));
} else {
if(f1Cur < f2Cur){
append(g1,f1Cur);
f1->read((char*) &f1Cur, sizeof(hSegment));
} else {
append(g1,f2Cur);
f2->read((char*) &f2Cur, sizeof(hSegment));
}
}
}
// both element are markers
append(g1,hSegment::getMarker());
runs++;
swap(g1,g2);
if(!f1Cur.isEnd()){
f1->read((char*) &f1Cur, sizeof(hSegment));
}
if(!f2Cur.isEnd()){
f2->read((char*) &f2Cur, sizeof(hSegment));
}
}
append(g1,hSegment::getEnd());
append(g2,hSegment::getEnd());
return runs ;
}
};
class ContourLineLocalInfo2{
public:
ContourLineLocalInfo2(ListExpr tupleType, size_t mem)
{
tt = new TupleType(tupleType);
store = new segmentStorage(mem);
}
~ContourLineLocalInfo2(){
tt->DeleteIfAllowed();
delete store;
}
void addSegment(int level, const Point& p1, const Point & p2){
hSegment seg(level,p1,p2);
store->insert(seg);
}
void finish(){
store->finish();
}
Tuple* getNext() {
if(!store->hasNext()){
return 0;
}
LineType* line = new LineType(0);
line->StartBulkLoad();
hSegment seg = store->current();
int level = seg.getLevel();
int edge = 0;
while(store->hasNext() && level == seg.getLevel()){
insert(seg,line, edge);
edge++;
store->next();
if(store->hasNext()){
seg = store->current();
}
}
line->EndBulkLoad();
Tuple* result = new Tuple(tt);
result->PutAttribute(0,new CcInt(true,level));
result->PutAttribute(1,line);
return result;
}
private:
segmentStorage* store;
TupleType* tt;
void insert(const hSegment seg, LineType* line, int edgeno){
HalfSegment hs(true,seg.getP1(), seg.getP2());
hs.attr.edgeno=edgeno;
(*line) += hs;
hs.SetLeftDomPoint(false);
(*line) += hs;
}
};
/*
Method ProcessRectangle returns true if processing was successful
Parameters: values and coordinates of four points, the wanted interval,
the minimum value and DbArray ResultInfo to store the found
segments
*/
template<class LI>
bool ProcessRectangle(double, double, double,
double, double, double,
double, double, double,
double, double, double,
int, LI*);
/*
Method AddSegment addes the found segments to the ResultInfo DbArray
Parameters: level value, coordinates of segments start and stop point,
the minimum value, the interval value and DbArray ResultInfo
to store the segments
*/
template<class LI>
void AddSegment(int, double, double,
double, double, LI*);
/*
Method contourFuns: calculates the contour lines for a given sint or sreal
object
Return value: stream of tuple (level, line)
*/
template <typename T>
int contourFun(Word* args, Word& result,
int message, Word& local, Supplier s)
{
int returnValue = FAILURE;
typename T::this_type* s_in =
static_cast<typename T::this_type*>(args[0].addr);
CcInt* lines = static_cast<CcInt*>(args[1].addr);
typedef ContourLineLocalInfo2 LIT;
LIT* li = (LIT*) local.addr;
switch(message)
{
case OPEN:
{
// initialize the local storage
double min = s_in->getMinimum();
double max = s_in->getMaximum();
if( !lines->IsDefined()
|| s_in->isUndefined(min) || s_in->isUndefined(max)){
return 0;
}
int interval = lines->GetValue();
if ( interval < 1 )
{
cmsg.error() << "Interval < 1 not allowed" << endl;
cmsg.send();
return CANCEL;
}
// double diff = max - min;
// int num = ceil(diff / interval) + 1;
if(li){ delete li; }
// li = new LIT(num,min, interval,
// nl->Second(GetTupleResultType(s)));
size_t mem;
#ifdef contourlines_fixed_cache
mem = 64*1024*1024;
#else
mem = qp->GetMemorySize(s)*1024*1024;
#endif
li = new LIT( nl->Second(GetTupleResultType(s)), mem);
local.addr = li;
raster2::grid2 grid = s_in->getGrid();
Rectangle<2> bbox = s_in->bbox();
double gridOriginX = grid.getOriginX();
double gridOriginY = grid.getOriginY();
double cellsize = grid.getLength();
raster2::RasterIndex<2> from =
grid.getIndex(bbox.MinD(0), bbox.MinD(1));
raster2::RasterIndex<2> to =
grid.getIndex(bbox.MaxD(0), bbox.MaxD(1));
for (raster2::RasterIndex<2> index = from; index < to;
index.increment(from, to))
{
// central cell
double e = s_in->get(index);
if (!(s_in->isUndefined(e)))
{
double a = s_in->get((int[]){index[0] - 1, index[1] + 1});
double a1 = s_in->get((int[]){index[0] - 1, index[1] + 2});
double b = s_in->get((int[]){index[0], index[1] + 1});
double b1 = s_in->get((int[]){index[0], index[1] + 2});
double c = s_in->get((int[]){index[0] + 1, index[1] + 1});
double d = s_in->get((int[]){index[0] - 1, index[1]});
double g = s_in->get((int[]){index[0] - 1, index[1] - 1});
double h = s_in->get((int[]){index[0], index[1] - 1});
double f = s_in->get((int[]){index[0] + 1, index[1]});
// calculate coordinates
double X = index[0] * cellsize + cellsize/2 + gridOriginX;
double Y = index[1] * cellsize + cellsize/2 + gridOriginY;
// if all four cells have valid values
if (!(s_in->isUndefined(a)) && !(s_in->isUndefined(b)) &&
!(s_in->isUndefined(d)) && !(s_in->isUndefined(e)))
{
// special case for bottom right cell
if ((s_in->isUndefined(h)) && (s_in->isUndefined(f)))
{
ProcessRectangle(a, X - cellsize, Y + cellsize,
d, X - cellsize, Y - cellsize/2,
e, X + cellsize/2, Y - cellsize/2,
b, X + cellsize/2, Y + cellsize,
interval, li);
}
// special case for first row
else if ((s_in->isUndefined(h)) && (s_in->isUndefined(g)))
{
ProcessRectangle(a, X - cellsize, Y + cellsize,
d, X - cellsize, Y - cellsize/2,
e, X, Y - cellsize/2,
b, X, Y + cellsize,
interval, li);
}
// special case for top right cell
else if ((s_in->isUndefined(f)) && (s_in->isUndefined(a1))
&& (s_in->isUndefined(b1)))
{
ProcessRectangle(a, X - cellsize, Y + cellsize + cellsize/2,
d, X - cellsize, Y,
e, X + cellsize/2, Y,
b, X + cellsize/2, Y + cellsize+cellsize/2,
interval, li);
}
// special case for last column
else if ((s_in->isUndefined(f)) && (s_in->isUndefined(c)))
{
ProcessRectangle(a, X - cellsize, Y + cellsize,
d, X - cellsize, Y,
e, X + cellsize/2, Y,
b, X + cellsize/2, Y + cellsize,
interval, li);
}
// special case for top row
else if ((s_in->isUndefined(a1)) && (s_in->isUndefined(b1)))
{
ProcessRectangle(a, X - cellsize, Y + cellsize + cellsize/2,
d, X - cellsize, Y,
e, X, Y,
b, X, Y + cellsize+cellsize/2,
interval, li);
}
// normal case
else
{
ProcessRectangle(a, X - cellsize, Y + cellsize,
d, X - cellsize, Y,
e, X, Y,
b, X, Y + cellsize,
interval, li);
}
}
else
{
// determine which cells have defined values, accumulate values
// and divide through number of valid cells
double sum = 0;
int good = 0;
double center = 0;
if (!(s_in->isUndefined(a)))
{
sum += a;
good++;
}
if (!(s_in->isUndefined(b)))
{
sum += b;
good++;
}
if (!(s_in->isUndefined(d)))
{
sum += d;
good++;
}
if (!(s_in->isUndefined(e)))
{
sum += e;
good++;
}
center = sum / good;
// calculate alternative values
double top;
double left;
double right;
double bottom;
if(!(s_in->isUndefined(a)))
{
if(!(s_in->isUndefined(b)))
top = (a + b) / 2.0;
else
top = a;
if(!(s_in->isUndefined(d)))
left = (a + d) / 2.0;
else
left = a;
}
else
{
if (!(s_in->isUndefined(b)))
top = b;
else
top = e;
if (!(s_in->isUndefined(d)))
left = d;
else
left = e;
}
if(!(s_in->isUndefined(b)))
right = (e + b) / 2.0;
else
right = e;
if(!(s_in->isUndefined(d)))
bottom = (e + d) / 2.0;
else
bottom = e;
// if one cell is not defined
// -> calculation with alternative values
if (!(s_in->isUndefined(a)))
{
ProcessRectangle(a, X - cellsize, Y + cellsize,
left, X - cellsize, Y + cellsize/2,
center, X - cellsize/2, Y + cellsize/2,
top, X - cellsize/2, Y + cellsize,
interval, li);
}
if (!(s_in->isUndefined(d)))
{
if ((s_in->isUndefined(f)) && (s_in->isUndefined(b)))
{
// special case top right cell
}
else if (!(s_in->isUndefined(e)) && !(s_in->isUndefined(d)) &&
(s_in->isUndefined(a)) && !(s_in->isUndefined(b)))
{
// special case cell under undefined cell
ProcessRectangle(left, X - cellsize, Y + cellsize/2,
d, X - cellsize, Y,
bottom, X - cellsize/2, Y,
center, X - cellsize/2, Y + cellsize/2,
interval, li);
}
else if (!(s_in->isUndefined(e)) && !(s_in->isUndefined(d)) &&
!(s_in->isUndefined(a)) && (s_in->isUndefined(b)))
{
// special case cell left under undefined cell
ProcessRectangle(left, X - cellsize, Y + cellsize/2,
d, X - cellsize, Y,
bottom, X - cellsize/2, Y,
center, X - cellsize/2, Y + cellsize/2,
interval, li);
}
}
if (!(s_in->isUndefined(e)) && (s_in->isUndefined(h))
&& (s_in->isUndefined(d)))
{
// special case left bottom cell
}
else if (!(s_in->isUndefined(e)) && (s_in->isUndefined(a)) &&
!(s_in->isUndefined(b)) && (s_in->isUndefined(b1)))
{
// special case top left cell
ProcessRectangle(b, X-cellsize/2, Y+cellsize+cellsize/2,
bottom, X - cellsize/2, Y,
e, X, Y,
b, X, Y + cellsize + cellsize/2,
interval, li);
}
else if (!(s_in->isUndefined(e)) && (s_in->isUndefined(a))
&& (s_in->isUndefined(b)))
{
// special case top row
}
else if (!(s_in->isUndefined(e)) && !(s_in->isUndefined(f)))
{
// special case right top cell
ProcessRectangle(center, X - cellsize/2, Y + cellsize/2,
bottom, X - cellsize/2, Y,
e, X, Y,
right, X, Y + cellsize/2,
interval, li);
}
if (!(s_in->isUndefined(e)) && (s_in->isUndefined(a)) &&
!(s_in->isUndefined(b)) && (s_in->isUndefined(b1)) &&
(s_in->isUndefined(a1)))
{
// special case left top cell
}
else if (!(s_in->isUndefined(b)) && (s_in->isUndefined(h)))
{
ProcessRectangle(top, X - cellsize/2, Y + cellsize,
e, X - cellsize/2, Y - cellsize/2,
e, X, Y - cellsize/2,
b, X, Y + cellsize,
interval, li);
}
else if (!(s_in->isUndefined(b)) && (s_in->isUndefined(d))
&& !(s_in->isUndefined(b1)))
{
ProcessRectangle(top, X - cellsize/2, Y + cellsize,
center, X - cellsize/2, Y + cellsize/2,
right, X, Y + cellsize/2,
b, X, Y + cellsize,
interval, li);
}
else if (!(s_in->isUndefined(b)) && !(s_in->isUndefined(e))
&& (s_in->isUndefined(a)))
{
// special case right of undefined
ProcessRectangle(top, X - cellsize/2, Y + cellsize,
center, X - cellsize/2, Y + cellsize/2,
right, X, Y + cellsize/2,
b, X, Y + cellsize,
interval, li);
}
}
}//if e def
}// for
li->finish();
return 0;
}
case REQUEST:
{
result.addr = li?li->getNext():0;
return result.addr?YIELD:CANCEL;
}
case CLOSE:
{
if(li){
delete li;
local.addr = 0;
}
return 0;
}
default:
{
assert(false);
}
}
return returnValue;
}
/*
Method contourFuns: calculates the contour lines for a given stream of
tint or treal objects
Return value: stream of tuple (level, line)
*/
template <typename T, typename SourceTypeProperties>
int contourFunTile(Word* args, Word& result,
int message, Word& local, Supplier s)
{
int returnValue = FAILURE;
CcInt* lines = static_cast<CcInt*>(args[1].addr);
vector<Tuple*> current;
vector<Tuple*> last;
vector<Tuple*> next;
Tuple* nextElement;
double fromX;
double fromY;
double toX;
double toY;
double tileSize;
double cellSize;
bool firstTuple = true;
bool readNextElement = true;
bool newLine = false;
bool skipNextRow;
bool skipLastRow;
int currentSize;
int nextSize;
int lastSize;
int currentTuple = 0;
int xDimensionSize = TileAlgebra::tProperties<char>::GetXDimensionSize();
int yDimensionSize = TileAlgebra::tProperties<char>::GetYDimensionSize();
int maxX = xDimensionSize - 1;
int maxY = yDimensionSize - 1;
//ContourLocalInfo* li = (ContourLocalInfo*) local.addr;
ContourLineLocalInfo2* li = (ContourLineLocalInfo2*) local.addr;
switch(message)
{
case OPEN:
{
if(!lines->IsDefined()){
return 0;
}
int interval = lines->GetValue();
// Check for valid interval
if ( interval < 1 )
{
cmsg.error() << "Interval < 1 not allowed" << endl;
cmsg.send();
return CANCEL;
}
Word elem;
Tuple* tuple;
T* s_in;
typename SourceTypeProperties::TypeProperties::PropertiesType min;
typename SourceTypeProperties::TypeProperties::PropertiesType max;
qp->Open(args[0].addr);
qp->Request(args[0].addr, elem);
bool firstValue = true;
// Get minimum and maximum values of complete tile
while(qp->Received(args[0].addr))
{
tuple = (Tuple*)elem.addr;
s_in = static_cast<T*>(tuple->GetAttribute(0));
typename SourceTypeProperties::TypeProperties::PropertiesType minTemp;
s_in->minimum(minTemp);
typename SourceTypeProperties::TypeProperties::PropertiesType maxTemp;
s_in->maximum(maxTemp);
if (firstValue ||(minTemp < min) )
{
min = minTemp;
}
if (firstValue || (maxTemp > max) )
{
max = maxTemp;
}
firstValue = false;
tuple->DeleteIfAllowed();
qp->Request(args[0].addr, elem);
}
qp->Close(args[0].addr);
// double diff = max - min;
// int num = ceil(diff / interval) + 1;
if(li) delete li;
// li = new ContourLocalInfo(num, min, interval,
// nl->Second(GetTupleResultType(s)));
size_t mem;
#ifdef contourlines_fixed_cache
mem = 64*1024*1024;
#else
mem = qp->GetMemorySize(s)*1024*1024;
#endif
li = new ContourLineLocalInfo2(
nl->Second(GetTupleResultType(s)),
mem);
local.addr = li;
qp->Open(args[0].addr);
double gridOriginX;
double gridOriginY;
double lastOriginX;
double lastOriginY;
while (readNextElement == true)
{
qp->Request(args[0].addr, elem);
if(qp->Received(args[0].addr))
{
tuple = (Tuple*)elem.addr;
s_in = static_cast<T*>(tuple->GetAttribute(0));
TileAlgebra::tgrid grid;
s_in->getgrid(grid);
gridOriginX = grid.GetX();
gridOriginY = grid.GetY();
cellSize = grid.GetLength();
tileSize = cellSize * xDimensionSize;
// read cells until Y coordinate changes
if ( firstTuple || (gridOriginY == lastOriginY) )
{
if (!(firstTuple == true))
{
// if there is a gap between two read tiles, fill vector
// with dummy tile
while ((gridOriginX - lastOriginX) - tileSize > cellSize)
{
TupleType *tupleType = tuple->GetTupleType();
Tuple* dummy = new Tuple( tupleType );
T* s_out = new T(true);
dummy->PutAttribute(0,s_out);
current.push_back(dummy);
lastOriginX = lastOriginX + tileSize;
}
}
current.push_back(tuple);
lastOriginX = gridOriginX;
lastOriginY = gridOriginY;
firstTuple = false;
}
else
{
readNextElement = false;
firstTuple = true;
next.push_back(tuple);
lastOriginX = gridOriginX;
}
}
else
{
readNextElement = false;
}
} // while currentLine
currentSize = current.size();
readNextElement = true;
while (currentSize != 0)
{
while (readNextElement == true)
{
qp->Request(args[0].addr, elem);
if(qp->Received(args[0].addr))
{
tuple = (Tuple*)elem.addr;
s_in = static_cast<T*>(tuple->GetAttribute(0));
TileAlgebra::tgrid grid;
s_in->getgrid(grid);
gridOriginX = grid.GetX();
gridOriginY = grid.GetY();
cellSize = grid.GetLength();
// read cells until Y coordinate changes
if ((gridOriginY == lastOriginY) || (firstTuple == true))
{
// if there is a gap between two read tiles, fill vector
// with dummy tile
while ((gridOriginX-lastOriginX) - tileSize > cellSize)
{
TupleType *tupleType = tuple->GetTupleType();
Tuple* dummy = new Tuple( tupleType );
T* s_out = new T(true);
dummy->PutAttribute(0,s_out);
next.push_back(dummy);
lastOriginX = lastOriginX + tileSize;
}
next.push_back(tuple);
lastOriginX = gridOriginX;
lastOriginY = gridOriginY;
firstTuple = false;
}
else
{
readNextElement = false;
firstTuple = true;
newLine = true;
nextElement = tuple;
lastOriginX = gridOriginX;
}
}
else
{
readNextElement = false;
}
} // while NextLine
int factorNext = 0;
int factorLast = 0;
skipNextRow = false;
skipLastRow = false;
nextSize = next.size();
lastSize = last.size();
Tuple* cTuple = current[0];
T* c = static_cast<T*>(cTuple->GetAttribute(0));
TileAlgebra::tgrid cGrid;
c->getgrid(cGrid);
double cGridOriginX = cGrid.GetX();
double cGridOriginY = cGrid.GetY();
if (nextSize > 0)
{
Tuple* nTuple = next[0];
T* n = static_cast<T*>(nTuple->GetAttribute(0));
TileAlgebra::tgrid nGrid;
n->getgrid(nGrid);
double nGridOriginX = nGrid.GetX();
double nGridOriginY = nGrid.GetY();
// calculate factor if tile rows starts at different coordinates
if ((cGridOriginX - nGridOriginX) > 0)
{
while ((cGridOriginX - nGridOriginX) > 0)
{
factorNext++;
nGridOriginX = nGridOriginX + tileSize;
}
}
else if ((cGridOriginX - nGridOriginX) < 0)
{
while ((cGridOriginX - nGridOriginX) < 0)
{
factorNext--;
cGridOriginX = cGridOriginX + tileSize;
}
}
// check if one or more rows are missing
if ((nGridOriginY - cGridOriginY) > tileSize)
{
skipNextRow = true;
}
}
if (lastSize > 0)
{
Tuple* lTuple = last[0];
T* l = static_cast<T*>(lTuple->GetAttribute(0));
TileAlgebra::tgrid lGrid;
l->getgrid(lGrid);
double lGridOriginX = lGrid.GetX();
double lGridOriginY = lGrid.GetY();
cGridOriginX = cGrid.GetX();
cGridOriginY = cGrid.GetY();
// calculate factor if tile rows starts at different coordinates
if ((cGridOriginX - lGridOriginX) > 0)
{
while ((cGridOriginX - lGridOriginX) > 0)
{
factorLast++;
lGridOriginX = lGridOriginX + tileSize;
}
}
else if ((cGridOriginX - lGridOriginX) < 0)
{
while ((cGridOriginX - lGridOriginX) < 0)
{
factorLast--;
cGridOriginX = cGridOriginX + tileSize;
}
}
// check if one or more rows are missing
if ((cGridOriginY - lGridOriginY) > tileSize)
{
skipLastRow = true;
}
}
while (currentTuple < currentSize)
{
tuple = current[currentTuple];
if ((tuple == 0) || (tuple->GetNoAttributes() != 1))
{
while (tuple == 0)
{
currentTuple++;
tuple = current[currentTuple];
}
while (tuple->GetNoAttributes() != 1)
{
currentTuple++;
tuple = current[currentTuple];
}
}
s_in = static_cast<T*>(tuple->GetAttribute(0));
TileAlgebra::Index<2> from;
TileAlgebra::Index<2> to;
s_in->GetBoundingBoxIndexes(from, to);
fromX = from[0];
fromY = from[1];
toX = to[0];
toY = to[1];
TileAlgebra::tgrid grid;
s_in->getgrid(grid);
cellSize = grid.GetLength();
gridOriginX = grid.GetX();
gridOriginY = grid.GetY();
for(int row = fromY; row <= toY; row++)
{
for(int column = fromX; column <= toX; column++)
{
TileAlgebra::Index<2> index((int[]){column, row});
// central cell
double e = s_in->GetValue(index);
if(!(SourceTypeProperties::TypeProperties::IsUndefinedValue(e)))
{
double a =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
double a1 =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
double b =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
double b1 =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
double c =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
double d =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
double f =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
double g =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
double h =
SourceTypeProperties::TypeProperties::GetUndefinedValue();
GetValuesContour<T, SourceTypeProperties>
(&a, &a1, &b, &b1, &c, &d, &f, &g, &h, row, column,
currentTuple, s_in,
maxX, maxY, factorNext, factorLast,
skipNextRow, skipLastRow,
current, next, last,
currentSize, nextSize, lastSize);
// calculate coordinates
double X = index[0] * cellSize + cellSize/2 + gridOriginX;
double Y = index[1] * cellSize + cellSize/2 + gridOriginY;
// if all four cells have valid values
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)))
{
// special case for bottom right cell
if ((SourceTypeProperties::TypeProperties::
IsUndefinedValue(h)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(f)))
{
ProcessRectangle(a, X - cellSize, Y + cellSize,
d, X - cellSize, Y - cellSize/2,
e, X + cellSize/2, Y - cellSize/2,
b, X + cellSize/2, Y + cellSize,
interval, li);
}
// special case for first row
else if ((SourceTypeProperties::TypeProperties::
IsUndefinedValue(h)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(g)))
{
ProcessRectangle(a, X - cellSize, Y + cellSize,
d, X - cellSize, Y - cellSize/2,
e, X, Y - cellSize/2,
b, X, Y + cellSize,
interval, li);
}
// special case for top right cell
else if ((SourceTypeProperties::TypeProperties::
IsUndefinedValue(f)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a1)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b1)))
{
ProcessRectangle(a, X - cellSize, Y+cellSize+cellSize/2,
d, X - cellSize, Y,
e, X + cellSize/2, Y,
b, X + cellSize/2, Y+cellSize+cellSize/2,
interval, li);
}
// special case for last column
else if ((SourceTypeProperties::TypeProperties::
IsUndefinedValue(f)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(c)))
{
ProcessRectangle(a, X - cellSize, Y + cellSize,
d, X - cellSize, Y,
e, X + cellSize/2, Y,
b, X + cellSize/2, Y + cellSize,
interval, li);
}
// special case for top row
else if ((SourceTypeProperties::TypeProperties::
IsUndefinedValue(a1)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b1)))
{
ProcessRectangle(a, X - cellSize, Y + cellSize+cellSize/2,
d, X - cellSize, Y,
e, X, Y,
b, X, Y + cellSize + cellSize/2,
interval, li);
}
// normal case
else
{
ProcessRectangle(a, X - cellSize, Y + cellSize,
d, X - cellSize, Y,
e, X, Y,
b, X, Y + cellSize,
interval, li);
}
}
else
{
// determine which cells have defined values, accumulate
// values and divide through number of valid cells
double sum = 0;
int good = 0;
double center = 0;
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)))
{
sum += a;
good++;
}
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)))
{
sum += b;
good++;
}
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)))
{
sum += d;
good++;
}
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)))
{
sum += e;
good++;
}
center = sum / good;
// calculate alternative values
double top;
double left;
double right;
double bottom;
if(!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)))
{
if(!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)))
top = (a + b) / 2.0;
else
top = a;
if(!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)))
left = (a + d) / 2.0;
else
left = a;
}
else
{
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)))
top = b;
else
top = e;
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)))
left = d;
else
left = e;
}
if(!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)))
right = (e + b) / 2.0;
else
right = e;
if(!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)))
bottom = (e + d) / 2.0;
else
bottom = e;
// if one cell is not defined
// -> calculation with alternative values
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)))
{
ProcessRectangle(a, X - cellSize, Y + cellSize,
left, X - cellSize, Y + cellSize/2,
center, X - cellSize/2, Y + cellSize/2,
top, X - cellSize/2, Y + cellSize,
interval, li);
}
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)))
{
if ((SourceTypeProperties::TypeProperties::
IsUndefinedValue(f)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)))
{
// special case top right cell
}
else if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)))
{
// special case cell under undefined cell
ProcessRectangle(left, X - cellSize, Y + cellSize/2,
d, X - cellSize, Y,
bottom, X - cellSize/2, Y,
center, X - cellSize/2, Y + cellSize/2,
interval, li);
}
else if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)))
{
// special case cell left under undefined cell
ProcessRectangle(left, X - cellSize, Y + cellSize/2,
d, X - cellSize, Y,
bottom, X - cellSize/2, Y,
center, X - cellSize/2, Y + cellSize/2,
interval, li);
}
}
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(h)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)))
{
// special case left bottom cell
}
else if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b1)))
{
// special case top left cell
ProcessRectangle(b, X-cellSize/2, Y+cellSize+cellSize/2,
bottom, X - cellSize/2, Y,
e, X, Y,
b, X, Y + cellSize + cellSize/2,
interval, li);
}
else if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)))
{
// special case top row
}
else if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(f)))
{
// special case right top cell
ProcessRectangle(center, X - cellSize/2, Y + cellSize/2,
bottom, X - cellSize/2, Y,
e, X, Y,
right, X, Y + cellSize/2,
interval, li);
}
if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b1)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a1)))
{
// special case left top cell
}
else if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(h)))
{
ProcessRectangle(top, X - cellSize/2, Y + cellSize,
e, X - cellSize/2, Y - cellSize/2,
e, X, Y - cellSize/2,
b, X, Y + cellSize,
interval, li);
}
else if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(d)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b1)))
{
ProcessRectangle(top, X - cellSize/2, Y + cellSize,
center, X - cellSize/2, Y + cellSize/2,
right, X, Y + cellSize/2,
b, X, Y + cellSize,
interval, li);
}
else if (!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(b)) &&
!(SourceTypeProperties::TypeProperties::
IsUndefinedValue(e)) &&
(SourceTypeProperties::TypeProperties::
IsUndefinedValue(a)))
{
// special case right of undefined
ProcessRectangle(top, X - cellSize/2, Y + cellSize,
center, X - cellSize/2, Y + cellSize/2,
right, X, Y + cellSize/2,
b, X, Y + cellSize,
interval, li);
}
}
}//if e def
}// for
}// for
currentTuple++;
}
// change of tile rows
for(size_t i=0;i<last.size();i++){
last[i]->DeleteIfAllowed();
}
last = current;
current = next;
next.clear();
currentSize = current.size();
if (newLine == true)
{
next.push_back(nextElement);
newLine = false;
}
currentTuple = 0;
readNextElement = true;
}
for(size_t i=0;i<last.size();i++){
last[i]->DeleteIfAllowed();
}
li->finish();
return 0;
}
case REQUEST:
{
result.addr=li?li->getNext():0;
return result.addr?YIELD:CANCEL;
}
case CLOSE:
{
if(li){
delete li;
local.addr = 0;
}
return 0;
}
default:
{
assert(false);
}
}
return returnValue;
}
/*
declaration of contourFuns array
*/
ValueMapping contourFuns[] =
{
contourFun<raster2::sint>,
contourFun<raster2::sreal>,
contourFunTile<TileAlgebra::tint, TileAlgebra::tProperties<int> >,
contourFunTile<TileAlgebra::treal, TileAlgebra::tProperties<double> >,
0
};
/*
Value Mapping
*/
int contourSelectFun(ListExpr args)
{
int nSelection = -1;
NList type(args);
if (type.first() == NList(raster2::sint::BasicType()))
{
return 0;
}
else if (type.first() == NList(raster2::sreal::BasicType()))
{
return 1;
}
ListExpr stream = nl->First(args);
NList list = nl->Second(nl->First(nl->Second(nl->Second(stream))));
if (list == TileAlgebra::tint::BasicType())
{
return 2;
}
if (list == TileAlgebra::treal::BasicType())
{
return 3;
}
return nSelection;
}
/*
Type Mapping
*/
ListExpr contourTypeMap(ListExpr args)
{
string error = "Expecting an sint, sreal or a stream of "
"tint or treal and an integer (interval).";
NList type(args);
ListExpr attrList=nl->TheEmptyList();
ListExpr attr1 = nl->TwoElemList( nl->SymbolAtom("Height"),
nl->SymbolAtom(CcInt::BasicType()));
ListExpr attr2 = nl->TwoElemList( nl->SymbolAtom("Contour"),
nl->SymbolAtom(LineType::BasicType()));
attrList = nl->TwoElemList( attr1, attr2 );
if(type.length() != 2)
{
return NList::typeError("two arguments required");
}
if ((type == NList(raster2::sint::BasicType(), CcInt::BasicType())) ||
(type == NList(raster2::sreal::BasicType(), CcInt::BasicType())))
{
return nl->TwoElemList(nl->SymbolAtom(Stream<Tuple>::BasicType()),
nl->TwoElemList(nl->SymbolAtom(Tuple::BasicType()),
attrList));
}
ListExpr stream = nl->First(args);
NList attr = nl->Second(args);
if(!listutils::isTupleStream(stream))
{
return listutils::typeError(error);
}
NList list = nl->Second(nl->First(nl->Second(nl->Second(stream))));
if((list == TileAlgebra::tint::BasicType() && attr == CcInt::BasicType()) ||
(list == TileAlgebra::treal::BasicType() && attr == CcInt::BasicType()))
{
return nl->TwoElemList(nl->SymbolAtom(Stream<Tuple>::BasicType()),
nl->TwoElemList(nl->SymbolAtom(Tuple::BasicType()),
attrList));
}
return listutils::typeError(error);
}
/*
Method ProcessRectangle returns true if processing was successful
Parameters: values and coordinates of four points, the wanted interval,
the minimum value and DbArray ResultInfo to store the found
segments
*/
template<class LI>
bool ProcessRectangle(double a, double aX, double aY,
double g, double gX, double gY,
double i, double iX, double iY,
double c, double cX, double cY,
int interval,
LI* li)
{
// calculate minimum and maximum
double Min = MIN(MIN(a,c),MIN(g,i));
double Max = MAX(MAX(a,c),MAX(g,i));
int startLevel = (int) floor(Min / interval);
int endLevel = (int) ceil(Max / interval);
// calculate intersection
for(int iLevel = startLevel; iLevel <= endLevel; iLevel++)
{
int level = iLevel * interval;
int nPoints = 0;
int nPoints1 = 0, nPoints2 = 0, nPoints3 = 0;
double pointsX[4], pointsY[4];
Intersect( a, aX, aY, g, gX, gY, i,
level, &nPoints, pointsX, pointsY );
nPoints1 = nPoints;
Intersect( g, gX, gY, i, iX, iY, c,
level, &nPoints, pointsX, pointsY );
nPoints2 = nPoints;
Intersect( i, iX, iY, c, cX, cY, a,
level, &nPoints, pointsX, pointsY );
nPoints3 = nPoints;
Intersect( c, cX, cY, a, aX, aY, g,
level, &nPoints, pointsX, pointsY );
if( nPoints == 2 )
{
// left and bottom
if ( nPoints1 == 1 && nPoints2 == 2)
{
if ( !(g == level && i == level) )
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
}
// left and right
else if ( nPoints1 == 1 && nPoints3 == 2 )
{
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
}
// left and top
else if ( nPoints1 == 1 && nPoints == 2 )
{
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
}
// bottom and right
else if( nPoints2 == 1 && nPoints3 == 2)
{
if ( !(c == level && i == level) )
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
}
// bottom and top
else if ( nPoints2 == 1 && nPoints == 2 )
{
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
}
// right and top
else if ( nPoints3 == 1 && nPoints == 2 )
{
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
}
else
{
return false;
}
}
if( nPoints == 3 )
{
// left, bottom and right
if ( nPoints1 == 1 && nPoints2 == 2 && nPoints3 == 3 )
{
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
AddSegment( level, pointsX[1], pointsY[1],
pointsX[2], pointsY[2], li);
}
// left, bottom and top
else if ( nPoints1 == 1 && nPoints2 == 2 && nPoints == 3 )
{
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
AddSegment( level, pointsX[0], pointsY[0],
pointsX[2], pointsY[2], li);
}
// bottom, right and top
else if ( nPoints2 == 1 && nPoints3 == 2 && nPoints == 3 )
{
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
AddSegment( level, pointsX[1], pointsY[1],
pointsX[2], pointsY[2], li);
}
// left, right and top
else if ( nPoints1 == 1 && nPoints3 == 2 && nPoints == 3 )
{
AddSegment( level, pointsX[0], pointsY[0],
pointsX[1], pointsY[1], li);
AddSegment( level, pointsX[1], pointsY[1],
pointsX[2], pointsY[2], li);
}
}
if( nPoints == 4 )
{
if ( !(c == level && a == level) )
{
AddSegment( level, pointsX[1], pointsY[1],
pointsX[2], pointsY[2], li);
AddSegment( level, pointsX[0], pointsY[0],
pointsX[3], pointsY[3], li);
}
}
}
return false;
}
/*
Method Intersects calculates if a line between two points intersects the level
Parameters: values and coordinates of two points, value of a third point,
the level value, a pointer for a counter to store the number
of intersect and two pointer two store the point where the line is
intersected
*/
void Intersect(double val1, double val1X, double val1Y,
double val2, double val2X, double val2Y,
double val3, double level, int *pnPoints,
double *ppointsX, double *ppointsY )
{
if( val1 < level && val2 >= level )
{
double diff = (level - val1) / (val2 - val1);
ppointsX[*pnPoints] = val1X * (1.0 - diff) + val2X * diff;
ppointsY[*pnPoints] = val1Y * (1.0 - diff) + val2Y * diff;
(*pnPoints)++;
}
else if( val1 > level && val2 <= level )
{
double diff = (level - val2) / (val1 - val2);
ppointsX[*pnPoints] = val2X * (1.0 - diff) + val1X * diff;
ppointsY[*pnPoints] = val2Y * (1.0 - diff) + val1Y * diff;
(*pnPoints)++;
}
else if( val1 == level && val2 == level && val3 != level )
{
ppointsX[*pnPoints] = val2X;
ppointsY[*pnPoints] = val2Y;
(*pnPoints)++;
}
}
/*
Method AddSegment addes the found segments to the ResultInfo DbArray
Parameters: level value, coordinates of segments start and stop point,
the minimum value, the interval value and DbArray ResultInfo
to store the segments
*/
template<class LI>
void AddSegment(int l, double startX, double startY,
double endX, double endY, LI* clines)
{
Point p1(true, startX, startY);
Point p2(true, endX, endY);
clines->addSegment(l,p1,p2);
}
/*
Method GetValuesContour reads the values for 3x3 cells
parameters:
a - reference to top left cell \\
a1 - reference to top left cell + 1 \\
b - reference to top middle cell \\
b1 - reference to top middle cell + 1 \\
c - reference to top right cell \\
d - reference to middle left cell \\
f - reference to middle right cell \\
g - reference to bottom left cell \\
h - reference to bottom right cell \\
row - number of current row \\
column - number of current column \\
currentTuple - number of current tuple \\
s\_in - current tuple \\
maxX - maximum X in a tuple \\
maxY - maximum Y in a tuple \\
factorNext - if vector current and next have different start points \\
factorlast - if vector current and last have different start points \\
skipNextRow - if difference between next and current is more
than one tile \\
skipLastRow - if difference between last and current is more
than one tile \\
current - current vector \\
next - next vector \\
last - last vector \\
currentSize - size of current vector \\
nextSize - size of next vector \\
lastSize - size of last vector \\
return value: -
exceptions: -
*/
template <typename T, typename SourceTypeProperties>
void GetValuesContour(double* a, double* a1, double* b, double* b1, double* c,
double* d, double* f, double* g, double* h,
int row, int column, int currentTuple, T* s_in,
int maxX, int maxY,
int factorNext, int factorLast,
bool skipNextRow, bool skipLastRow,
vector<Tuple*> current, vector<Tuple*> next,
vector<Tuple*> last,
int currentSize, int nextSize, int lastSize)
{
Tuple* tuple_help;
T* s_in_help;
// left lower corner
if ((column == 0) && (row == 0))
{
if (currentTuple > 0)
{
tuple_help = current[currentTuple - 1];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a = s_in_help->GetValue((int[]){maxX, 1});
*a1 = s_in_help->GetValue((int[]){maxX, 2});
*d = s_in_help->GetValue((int[]){maxX, 0});
}
}
*b = s_in->GetValue((int[]){column, row + 1});
*b1 = s_in->GetValue((int[]){column, row + 2});
*c = s_in->GetValue((int[]){column + 1, row + 1});
*f = s_in->GetValue((int[]){column + 1, row});
if ((lastSize > 0) && (skipLastRow == false))
{
if ((currentTuple + factorLast > 0) &&
(currentTuple + factorLast - 1 < lastSize))
{
tuple_help = last[currentTuple - 1 + factorLast];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*g = s_in_help->GetValue((int[]){maxX, maxY});
}
}
if ((currentTuple + factorLast >= 0) &&
(currentTuple + factorLast < lastSize))
{
tuple_help = last[currentTuple + factorLast];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*h = s_in_help->GetValue((int[]){0, maxY});
}
}
}
}
// left upper corner - 1
else if ((column == 0) && (row == maxY - 1))
{
if ((nextSize > 0) && (skipNextRow == false))
{
if ((currentTuple + factorNext > 0) &&
(currentTuple + factorNext - 1 < nextSize))
{
tuple_help = next[currentTuple - 1 + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a1 = s_in_help->GetValue((int[]){maxX, 0});
}
}
if ((currentTuple + factorNext >= 0) &&
(currentTuple + factorNext < nextSize))
{
tuple_help = next[currentTuple + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*b1 = s_in_help->GetValue((int[]){0, 0});
}
}
}
if (currentTuple > 0)
{
tuple_help = current[currentTuple - 1];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a = s_in_help->GetValue((int[]){maxX, maxY});
*d = s_in_help->GetValue((int[]){maxX, maxY - 1});
*g = s_in_help->GetValue((int[]){maxX, maxY - 2});
}
}
*b = s_in->GetValue((int[]){column, row + 1});
*c = s_in->GetValue((int[]){column + 1, row + 1});
*f = s_in->GetValue((int[]){column + 1, row});
*h = s_in->GetValue((int[]){column, row - 1});
}
// left upper corner
else if ((column == 0) && (row == maxY))
{
if ((nextSize > 0) && (skipNextRow == false))
{
if ((currentTuple + factorNext > 0) &&
(currentTuple + factorNext - 1 < nextSize))
{
tuple_help = next[currentTuple - 1 + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a = s_in_help->GetValue((int[]){maxX, 0});
*a1 = s_in_help->GetValue((int[]){maxX, 1});
}
}
if ((currentTuple + factorNext >= 0) &&
(currentTuple + factorNext < nextSize))
{
tuple_help = next[currentTuple + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*b = s_in_help->GetValue((int[]){0, 0});
*b1 = s_in_help->GetValue((int[]){0, 1});
*c = s_in_help->GetValue((int[]){1, 0});
}
}
}
if (currentTuple > 0)
{
tuple_help = current[currentTuple - 1];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*d = s_in_help->GetValue((int[]){maxX, maxY});
*g = s_in_help->GetValue((int[]){maxX, maxY - 1});
}
}
*f = s_in->GetValue((int[]){column + 1, row});
*h = s_in->GetValue((int[]){column, row - 1});
}
// right lower corner
else if ((column == maxX) && (row == 0))
{
*a = s_in->GetValue((int[]){column - 1, row + 1});
*a1 = s_in->GetValue((int[]){column - 1, row + 2});
*b = s_in->GetValue((int[]){column, row + 1});
*b1 = s_in->GetValue((int[]){column, row + 2});
*d = s_in->GetValue((int[]){column - 1, row});
if (currentTuple + 1 < currentSize)
{
tuple_help = current[currentTuple + 1];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*c = s_in_help->GetValue((int[]){0, 1});
*f = s_in_help->GetValue((int[]){0, 0});
}
}
if ((lastSize > 0) && (skipLastRow == false))
{
if ((currentTuple + factorLast >= 0) &&
(currentTuple + factorLast < lastSize))
{
tuple_help = last[currentTuple + factorLast];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*g = s_in_help->GetValue((int[]){maxX - 1, maxY});
*h = s_in_help->GetValue((int[]){maxX, maxY});
}
}
}
}
// right upper corner - 1
else if ((column == maxX) && (row == maxY - 1))
{
if ((nextSize > 0) && (skipNextRow == false))
{
if ((currentTuple + factorNext >= 0) &&
(currentTuple + factorNext < nextSize))
{
tuple_help = next[currentTuple + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a1 = s_in_help->GetValue((int[]){maxX - 1, 0});
*b1 = s_in_help->GetValue((int[]){maxX, 0});
}
}
}
*a = s_in->GetValue((int[]){column - 1, row + 1});
*b = s_in->GetValue((int[]){column, row + 1});
*d = s_in->GetValue((int[]){column - 1, row});
*g = s_in->GetValue((int[]){column - 1, row - 1});
*h = s_in->GetValue((int[]){column, row - 1});
if (currentTuple + 1 < currentSize)
{
tuple_help = current[currentTuple + 1];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*c = s_in_help->GetValue((int[]){0, maxY});
*f = s_in_help->GetValue((int[]){0, maxY - 1});
}
}
}
// right upper corner
else if ((column == maxX) && (row == maxY))
{
if ((nextSize > 0) && (skipNextRow == false))
{
if ((currentTuple + factorNext >= 0) &&
(currentTuple + factorNext < nextSize))
{
tuple_help = next[currentTuple + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a = s_in_help->GetValue((int[]){maxX - 1, 0});
*a1 = s_in_help->GetValue((int[]){maxX - 1, 1});
*b = s_in_help->GetValue((int[]){maxX, 0});
*b1 = s_in_help->GetValue((int[]){maxX, 1});
}
}
if ((currentTuple + factorNext >= 0) &&
(currentTuple + factorNext + 1 < nextSize))
{
tuple_help = next[currentTuple + 1 + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*c = s_in_help->GetValue((int[]){0, 0});
}
}
}
*d = s_in->GetValue((int[]){column - 1, row});
*g = s_in->GetValue((int[]){column - 1, row - 1});
*h = s_in->GetValue((int[]){column, row - 1});
if (currentTuple + 1 < currentSize)
{
tuple_help = current[currentTuple + 1];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*f = s_in_help->GetValue((int[]){0, maxY});
}
}
}
// left column
else if (column == 0)
{
*b = s_in->GetValue((int[]){column, row + 1});
*b1 = s_in->GetValue((int[]){column, row + 2});
*c = s_in->GetValue((int[]){column + 1, row + 1});
*f = s_in->GetValue((int[]){column + 1, row});
*h = s_in->GetValue((int[]){column, row - 1});
if (currentTuple > 0)
{
tuple_help = current[currentTuple - 1];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a = s_in_help->GetValue((int[]){maxX, row + 1});
*a1 = s_in_help->GetValue((int[]){maxX, row + 2});
*d = s_in_help->GetValue((int[]){maxX, row});
*g = s_in_help->GetValue((int[]){maxX, row - 1});
}
}
}
// lower row
else if (row == 0)
{
*a = s_in->GetValue((int[]){column - 1, row + 1});
*a1 = s_in->GetValue((int[]){column - 1, row + 2});
*b = s_in->GetValue((int[]){column, row + 1});
*b1 = s_in->GetValue((int[]){column, row + 2});
*c = s_in->GetValue((int[]){column + 1, row + 1});
*d = s_in->GetValue((int[]){column - 1, row});
*f = s_in->GetValue((int[]){column + 1, row});
if ((lastSize > 0) && (skipLastRow == false))
{
if ((currentTuple + factorLast >= 0) &&
(currentTuple + factorLast < lastSize))
{
tuple_help = last[currentTuple + factorLast];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*g = s_in_help->GetValue((int[]){column - 1, maxY});
*h = s_in_help->GetValue((int[]){column, maxY});
}
}
}
}
// right column
else if (column == maxX)
{
*a = s_in->GetValue((int[]){column - 1, row + 1});
*a1 = s_in->GetValue((int[]){column - 1, row + 2});
*b = s_in->GetValue((int[]){column, row + 1});
*b1 = s_in->GetValue((int[]){column, row + 2});
*d = s_in->GetValue((int[]){column - 1, row});
*g = s_in->GetValue((int[]){column - 1, row - 1});
*h = s_in->GetValue((int[]){column, row - 1});
if (currentTuple + 1 < currentSize)
{
tuple_help = current[currentTuple + 1];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*c = s_in_help->GetValue((int[]){0, row + 1});
*f = s_in_help->GetValue((int[]){0, row});
}
}
}
// upper row - 1
else if (row == maxY - 1)
{
*a = s_in->GetValue((int[]){column - 1, row + 1});
*b = s_in->GetValue((int[]){column, row + 1});
*c = s_in->GetValue((int[]){column + 1, row + 1});
*d = s_in->GetValue((int[]){column - 1, row});
*f = s_in->GetValue((int[]){column + 1, row});
*g = s_in->GetValue((int[]){column - 1, row - 1});
*h = s_in->GetValue((int[]){column, row - 1});
if ((nextSize > 0) && (skipNextRow == false))
{
if ((currentTuple + factorNext >= 0) &&
(currentTuple + factorNext < nextSize))
{
tuple_help = next[currentTuple + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a1 = s_in_help->GetValue((int[]){column - 1, 0});
*b1 = s_in_help->GetValue((int[]){column, 0});
}
}
}
}
// upper row
else if (row == maxY)
{
*d = s_in->GetValue((int[]){column - 1, row});
*f = s_in->GetValue((int[]){column + 1, row});
*g = s_in->GetValue((int[]){column - 1, row - 1});
*h = s_in->GetValue((int[]){column, row - 1});
if ((nextSize > 0) && (skipNextRow == false))
{
if ((currentTuple + factorNext >= 0) &&
(currentTuple + factorNext < nextSize))
{
tuple_help = next[currentTuple + factorNext];
if ((tuple_help != 0) && (tuple_help->GetNoAttributes() == 1))
{
s_in_help = static_cast<T*>(tuple_help->GetAttribute(0));
*a = s_in_help->GetValue((int[]){column - 1, 0});
*a1 = s_in_help->GetValue((int[]){column - 1, 1});
*b = s_in_help->GetValue((int[]){column, 0});
*b1 = s_in_help->GetValue((int[]){column, 1});
*c = s_in_help->GetValue((int[]){column + 1, 0});
}
}
}
}
// no border cells
else
{
*a = s_in->GetValue((int[]){column - 1, row + 1});
*a1 = s_in->GetValue((int[]){column - 1, row + 2});
*b = s_in->GetValue((int[]){column, row + 1});
*b1 = s_in->GetValue((int[]){column, row + 2});
*c = s_in->GetValue((int[]){column + 1, row + 1});
*d = s_in->GetValue((int[]){column - 1, row});
*f = s_in->GetValue((int[]){column + 1, row});
*g = s_in->GetValue((int[]){column - 1, row - 1});
*h = s_in->GetValue((int[]){column, row - 1});
}
}
}
Reference in New Issue Copy Permalink