279 lines
9.9 KiB
C++
279 lines
9.9 KiB
C++
/*
|
|
----
|
|
This file is part of SECONDO.
|
|
|
|
Copyright (C) 2004, 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 "Algebra.h"
|
|
#include "NestedList.h"
|
|
#include "QueryProcessor.h"
|
|
#include "Tin.h"
|
|
#include "Stream.h"
|
|
#include "Algebras/Raster2/stype.h"
|
|
#include "Algebras/Raster2/sreal.h"
|
|
|
|
extern NestedList* nl;
|
|
extern QueryProcessor *qp;
|
|
|
|
namespace tin {
|
|
|
|
int selectTheOne(ListExpr args) {
|
|
return 0;
|
|
}
|
|
|
|
struct atlocationInfo: OperatorInfo {
|
|
atlocationInfo() {
|
|
name = "atlocation";
|
|
signature = "{" + Tin::BasicType() + "|" + TinAttribute::BasicType()
|
|
+ "} x " + CcReal::BasicType() + " x " + CcReal::BasicType() + " -> "
|
|
+ CcReal::BasicType();
|
|
syntax = "_ atlocation [_, _]";
|
|
meaning = "Returns the height value at location given by"
|
|
" the coordinates x and y. If the point is "
|
|
"not contained in the tin, the result is undefined.";
|
|
example = "query ortetin atlocation[3.6 , 4.1]";
|
|
|
|
}
|
|
};
|
|
ValueMapping atlocationVM[] = { tin::Tin::atlocation_vm,
|
|
tin::TinAttribute::atlocation_vm, 0 };
|
|
struct tin2stlfileInfo: OperatorInfo {
|
|
tin2stlfileInfo() {
|
|
name = "tin2stlfile";
|
|
signature = Tin::BasicType() + " x " + CcString::BasicType() + " -> "
|
|
+ CcBool::BasicType() + " x (File in .stl format)";
|
|
syntax = "_ tin2stlfile _";
|
|
meaning = "The operator produces a .stl file from the tin in "
|
|
"the first parameter at the path given by the second"
|
|
" parameter. If the file already exists, it will be "
|
|
"overwritten. Thus the tin can be viewed in a CAD tool"
|
|
" or in a viewer like meshlab. If the file is created"
|
|
" successfully TRUE is returned, otherwise FALSE.";
|
|
example = " query ortetin tin2stlfile './mytin.stl'";
|
|
|
|
}
|
|
};
|
|
ValueMapping tin2stlfileVM[] = { tin::Tin::tin2stlfile_vm, 0 };
|
|
struct tin2tinattributeInfo: OperatorInfo {
|
|
tin2tinattributeInfo() {
|
|
name = "tin2tinattribute";
|
|
signature = Tin::BasicType() + " -> stream( tuple ([TinPart : "
|
|
+ TinAttribute::BasicType() + " ]))";
|
|
syntax = "_ tin2tinattribute";
|
|
meaning = "Returns a stream of tuples."
|
|
" Each tuple contains just one attribute of "
|
|
"type tinattribute, which represents"
|
|
" a TinPart of the input tin. ";
|
|
example = "query ortetin tin2tinattribute";
|
|
|
|
}
|
|
};
|
|
ValueMapping tin2tinattributeVM[] = { tin::Tin::tin2tinattribute_vm, 0 };
|
|
struct tinattribute2tinInfo: OperatorInfo {
|
|
tinattribute2tinInfo() {
|
|
name = "tinattribute2tin";
|
|
signature = "stream (tuple([T:tinattribute])) -> " + Tin::BasicType();
|
|
syntax = "_ tinattribute2tin ";
|
|
meaning = "Converts a stream of tuples with "
|
|
"just a tinattribute to a tin. "
|
|
"The tinattributes are not merged with any operation."
|
|
" They are just collected in a tin. "
|
|
"Thus there can be undetermined behavior "
|
|
"if the tinattributes are overlapping. There are no checks !";
|
|
example = "query tinrel feed project[Tin] tin2tinattribute";
|
|
|
|
}
|
|
};
|
|
ValueMapping tinattribute2tinVM[] = {
|
|
tin::TinAttribute::tinattribute2tin_vm, 0 };
|
|
|
|
struct unaryOpInfo: OperatorInfo {
|
|
unaryOpInfo() {
|
|
name = "unaryOp";
|
|
signature = Tin::BasicType() + " x (" + CcReal::BasicType() + "-> "
|
|
+ CcReal::BasicType() + " ) ->" + Tin::BasicType();
|
|
syntax = "_ unaryOp _";
|
|
meaning = "Returns a new tin with the height values of the given tin "
|
|
"manipulated by the function given with parameter two."
|
|
" The TinParts will have the same"
|
|
" size as configured in the input tin.";
|
|
example = "query (orte feed project[ Ort ] extend [Y: gety( .Ort) ] "
|
|
"sortby [Y desc] createTin 4000) unaryOp [fun(n:real) n + 10.0 ]";
|
|
}
|
|
};
|
|
ValueMapping unaryOpVM[] = { tin::Tin::unaryOp_vm, 0 };
|
|
|
|
struct tinminInfo: OperatorInfo {
|
|
tinminInfo() {
|
|
name = "tinmin";
|
|
signature = "{" + Tin::BasicType() + " | " + TinAttribute::BasicType()
|
|
+ " } ->" + CcReal::BasicType();
|
|
syntax = " tinmin ( _ )";
|
|
meaning = "Returns the minimum height value of a tin.";
|
|
example = "query tinmin(ortetin) ";
|
|
}
|
|
};
|
|
ValueMapping tinminVM[] = { tin::Tin::tinmin_vm,
|
|
tin::TinAttribute::tinmin_vm, 0 };
|
|
|
|
struct tinmaxInfo: OperatorInfo {
|
|
tinmaxInfo() {
|
|
name = "tinmax";
|
|
signature = "{" + Tin::BasicType() + " | " + TinAttribute::BasicType()
|
|
+ " } ->" + CcReal::BasicType();
|
|
syntax = " tinmax ( _ )";
|
|
meaning = "Returns the maximum height value of a tin.";
|
|
example = "query tinmax( ortetin ) ";
|
|
}
|
|
};
|
|
ValueMapping tinmaxVM[] = { tin::Tin::tinmax_vm,
|
|
tin::TinAttribute::tinmax_vm, 0 };
|
|
struct raster2tinInfo: OperatorInfo {
|
|
raster2tinInfo() {
|
|
name = "raster2tin";
|
|
signature = "{sreal|sint} x int ->" + Tin::BasicType();
|
|
syntax = "_ raster2tin _ ";
|
|
meaning = "Returns a new tin with all raster cells"
|
|
" as vertices being triangulated (Delaunay triangulation). "
|
|
"The second parameter configures the maximum"
|
|
" size of the TinParts in bytes.";
|
|
example = " robj raster2tin 4000 ";
|
|
remark = "To get tins from a raster with fewer triangles,"
|
|
" one can use contour lines."
|
|
" See operator createTin for more information.";
|
|
}
|
|
};
|
|
ValueMapping raster2tinVM[] = { tin::Tin::raster2tin_vm<raster2::sint>,
|
|
tin::Tin::raster2tin_vm<raster2::sreal>, 0 };
|
|
|
|
struct createTinInfo: OperatorInfo {
|
|
createTinInfo() {
|
|
name = "createTin";
|
|
signature = "stream (tuple([P:point,H:{real|int}] )) x "
|
|
+ CcInt::BasicType() + " -> " + Tin::BasicType();
|
|
syntax = "_ createTin _";
|
|
meaning = "Returns a tin from a stream of tuples and an integer defining"
|
|
" the size of the TinParts in bytes. The tuples have to consist"
|
|
" of a point attribute (coordinate) and a real|int attribute "
|
|
"(height value). (tuple (point real)) "
|
|
"The points will be triangulated (Delaunay triangulation)."
|
|
" ATTENTION: The points have to be ordered by the y coordinate"
|
|
" in DESCENDING order.";
|
|
example = " ";
|
|
remark =
|
|
"To produce tins with only few triangles from a raster,"
|
|
" one can use operator contourlines from GisAlgebra.let contourrelation "
|
|
"= raster contourlines[40] feed extendstream["
|
|
"V:components(vertices(.Contour)) ]"
|
|
" extend[P:center(.V),H:.Height] extend[Y:gety(.P)]"
|
|
" sortby[Y desc] project[P,H]"
|
|
" consume ; let smalltinfromraster = contourrelation feed createTin 4000";
|
|
}
|
|
};
|
|
ValueMapping createTinVM[] = { tin::Tin::createTin_vm<CcReal>,
|
|
tin::Tin::createTin_vm<CcInt>, 0 };
|
|
struct tin2tuplestreamInfo: OperatorInfo {
|
|
tin2tuplestreamInfo() {
|
|
name = "tin2tuplestream";
|
|
signature = Tin::BasicType() + " -> stream( tuple([V1:point , H1:real ,"
|
|
" V2:point , H2:real, V3:point , H3:real, Part:integer] ))";
|
|
syntax = "_ tin2tuplestream";
|
|
meaning = "Returns a stream of tuples from a tin. Each tuple "
|
|
"represents a triangle and consists of 7 attributes."
|
|
" Two attributes (point and height) for each vertex"
|
|
" of a triangle and an attribute part indicating"
|
|
" the part in which the triangle is contained.";
|
|
example = " query ortetin tin2tuplestream consume";
|
|
}
|
|
};
|
|
ValueMapping tin2tuplestreamVM[] = { tin::Tin::tin2tuplestream_vm, 0 };
|
|
|
|
TypeConstructor TinType(tin::Tin::BasicType(), //name
|
|
tin::Tin::Property, //property function describing signature
|
|
tin::Tin::Out, tin::Tin::In, //Out and In functions
|
|
0, 0, //SaveToList and RestoreFromList functions
|
|
tin::Tin::Create, tin::Tin::Delete, //object creation and deletion
|
|
tin::Tin::Open, tin::Tin::Save, tin::Tin::Close, tin::Tin::Clone, 0,
|
|
tin::Tin::sizeOfObj, //sizeof function
|
|
tin::Tin::CheckType); //kind checking function
|
|
|
|
TypeConstructor TinAttributeType(
|
|
tin::TinAttribute::BasicType(), //name
|
|
tin::TinAttribute::Property, //property function describing signature
|
|
tin::TinAttribute::Out,
|
|
tin::TinAttribute::In, //Out and In functions
|
|
0,
|
|
0, //SaveToList and RestoreFromList functions
|
|
tin::TinAttribute::Create,
|
|
tin::TinAttribute::Delete, //object creation and deletion
|
|
tin::TinAttribute::Open, tin::TinAttribute::Save,
|
|
tin::TinAttribute::Close, tin::TinAttribute::Clone,
|
|
tin::TinAttribute::Cast, //cast function
|
|
tin::TinAttribute::sizeOfObj, //sizeof function
|
|
tin::TinAttribute::CheckType); //kind checking function
|
|
|
|
class TinAlgebra: public Algebra {
|
|
public:
|
|
TinAlgebra() :
|
|
Algebra() {
|
|
AddTypeConstructor(&TinType);
|
|
TinType.AssociateKind(Kind::SIMPLE());
|
|
|
|
AddTypeConstructor(&TinAttributeType);
|
|
TinAttributeType.AssociateKind(Kind::DATA());
|
|
|
|
AddOperator(atlocationInfo(), atlocationVM, Tin::atlocation_sf,
|
|
Tin::atlocation_tm);
|
|
AddOperator(tin2stlfileInfo(), tin2stlfileVM, selectTheOne,
|
|
Tin::tin2stlfile_tm);
|
|
AddOperator(tinminInfo(), tinminVM, Tin::tinmin_sf, Tin::tinmin_tm);
|
|
AddOperator(tinmaxInfo(), tinmaxVM, Tin::tinmax_sf, Tin::tinmax_tm);
|
|
AddOperator(createTinInfo(), createTinVM, Tin::createTin_sf,
|
|
Tin::createTin_tm);
|
|
AddOperator(unaryOpInfo(), unaryOpVM, selectTheOne, Tin::unaryOp_tm);
|
|
AddOperator(raster2tinInfo(), raster2tinVM, Tin::raster2tin_sf,
|
|
Tin::raster2tin_tm);
|
|
AddOperator(tin2tuplestreamInfo(), tin2tuplestreamVM, selectTheOne,
|
|
Tin::tin2tuplestream_tm);
|
|
AddOperator(tin2tinattributeInfo(), tin2tinattributeVM, selectTheOne,
|
|
Tin::tin2tinattribute_tm);
|
|
AddOperator(tinattribute2tinInfo(), tinattribute2tinVM,
|
|
TinAttribute::tinattribute2tin_sf, TinAttribute::tinattribute2tin_tm);
|
|
}
|
|
~TinAlgebra() {
|
|
}
|
|
};
|
|
|
|
}
|
|
/*
|
|
|
|
5 Initialization
|
|
|
|
*/
|
|
|
|
extern "C" Algebra*
|
|
InitializeTinAlgebra(NestedList *nlRef, QueryProcessor *qpRef) {
|
|
nl = nlRef;
|
|
qp = qpRef;
|
|
return (new tin::TinAlgebra());
|
|
}
|
|
|