along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/SPart2/IrregularGrid3D.cpp
along dfd1e74548 firs commit
2026-01-23 17:03:45 +08:00

2044 lines
57 KiB
C++
Raw Blame History

/*
----
This file is part of SECONDO.
Copyright (C) 2020,
University in Hagen,
Faculty of Mathematics and 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 "IrregularGrid3D.h"
#include "Algebras/Relation-C++/RelationAlgebra.h"
#include "Algebras/Collection/IntSet.h"
#include <map>
#include <iterator>
/*
Class Cell3D
*/
Cell3D::Cell3D() {
cellId = -1;
valFrom = -1;
valTo = -1;
nbrPoints = -1;
}
void
Cell3D::setCellId(int cell_id) {
this->cellId = cell_id;
}
int
Cell3D::getCellId() {
return cellId;
}
void
Cell3D::setValFrom(double val_from) {
valFrom = val_from;
}
double
Cell3D::getValFrom() {
return valFrom;
}
void
Cell3D::setValTo(double val_to) {
valTo = val_to;
}
double
Cell3D::getValTo() {
return valTo;
}
int
Cell3D::getNbrOfPoints() {
return nbrPoints;
}
void
Cell3D::setNbrOfPoints(int nbr_points) {
nbrPoints = nbr_points;
}
Cell3D::~Cell3D() { }
/*
Class VCell3D
*/
VCell3D::VCell3D() { }
std::vector<HCell3D>&
VCell3D::getRow() {
return row;
}
VCell3D::~VCell3D() { }
/*
Class SCell3D
*/
SCell::SCell() {
upper = nullptr;
neighbor = nullptr;
}
std::vector<SCell>&
HCell3D::getRect() {
return rect;
}
void
SCell::setUpper(SCell* upper_) {
upper = upper_;
}
SCell*
SCell::getUpper() {
return upper;
}
void
SCell::setNeighbor(SCell* neighbor_) {
neighbor = neighbor_;
}
SCell*
SCell::getNeighbor() {
return neighbor;
}
SCell::~SCell() { }
/*
Class HCell3D
*/
HCell3D::HCell3D() { }
HCell3D::~HCell3D() { }
/*
Class IrregularGrid3D
*/
IrregularGrid3D::IrregularGrid3D() {
boundingBox = nullptr;
rowCount = 0;
cellCount = 0;
layerCount = 0;
}
IrregularGrid3D::IrregularGrid3D(const IrregularGrid3D& g) {
boundingBox = g.boundingBox;
rowCount = g.rowCount;
cellCount = g.cellCount;
layerCount = g.layerCount;
}
IrregularGrid3D::IrregularGrid3D(Rectangle<3> &bounding_box,
int row_count, int cell_count, int layer_count) {
boundingBox = &bounding_box;
rowCount = row_count;
cellCount = cell_count;
layerCount = layer_count;
}
void
IrregularGrid3D::Set(Stream<Rectangle<3>> rStream,
Rectangle<3> &bounding_box,
int row_count, int cell_count, int layer_count) {
boundingBox = &bounding_box;
rowCount = row_count;
cellCount = cell_count;
layerCount = layer_count;
createIrgrid3D(rStream);
}
void
IrregularGrid3D::SetVector(std::vector<Rectangle<3>>* rVector,
Rectangle<3> &bounding_box,
int row_count, int cell_count, int layer_count) {
boundingBox = &bounding_box;
rowCount = row_count;
cellCount = cell_count;
layerCount = layer_count;
createIrgrid3DVector(rVector);
}
std::vector<CellInfo3D*>
IrregularGrid3D::getCellInfoVector(IrregularGrid3D *in_irgrid3d) {
std::vector<CellInfo3D*> cell_info_vect {};
/*
Divide space vertical => horizontal => spatial
SCells are final cells
*/
std::vector<VCell3D>* col = &in_irgrid3d->getColumnVector();
for(size_t colIdx = 0; colIdx < col->size(); colIdx++) {
VCell3D* vcell = &col->at(colIdx);
double vf = vcell->getValFrom();
double vt = vcell->getValTo();
std::vector<HCell3D>* row_vect = &vcell->getRow();
for(size_t cellIdx = 0; cellIdx < row_vect->size(); cellIdx++) {
HCell3D* cell = &row_vect->at(cellIdx);
int cid = cell->getCellId();
double hf = cell->getValFrom();
double ht = cell->getValTo();
std::vector<SCell>* rect_vect = &cell->getRect();
for(size_t rectIdx = 0; rectIdx < rect_vect->size(); rectIdx++) {
SCell* rect = &rect_vect->at(rectIdx);
int scid = rect->getCellId();
int nps = rect->getNbrOfPoints();
double sf = rect->getValFrom();
double st = rect->getValTo();
CellInfo3D* ci = new CellInfo3D(scid, cid, nps, hf, ht, vf, vt, sf, st);
cell_info_vect.push_back(ci);
}
}
}
return cell_info_vect;
}
void
IrregularGrid3D::createIrgrid3D(Stream<Rectangle<3>> rStream) {
// sort input points by y-coordinates
processInput(rStream);
// create irregular grid 3d by point density
buildGrid();
}
void
IrregularGrid3D::createIrgrid3DVector(std::vector<Rectangle<3>>* rVector) {
// sort input points by y-coordinates
processInputVector(rVector);
// create irregular grid 3d by point density
buildGrid();
}
bool
pointComparisonX(CPoint p1, CPoint p2) {
return p1.x < p2.x;
}
bool
pointComparisonZ(CPoint p1, CPoint p2) {
return p1.z < p2.z;
}
void
IrregularGrid3D::buildGrid() {
// create grid structure
double bb_top = boundingBox->getMaxY();
double bb_bot = boundingBox->getMinY();
double colOffset = (bb_top - bb_bot) / rowCount;
double bb_right = boundingBox->getMaxX();
double bb_left = boundingBox->getMinX();
double hOffset = (bb_right - bb_left) / cellCount;
double bb_bck = boundingBox->getMaxZ();
double bb_frnt = boundingBox->getMinZ();
double sOffset = (bb_bck - bb_frnt) / layerCount;
double col_boundary_val = bb_bot;
int hcell_id = 1;
int scell_id = 1;
// first divide space by rows
for(int c = 0; c < rowCount; c++) {
VCell3D vcell = VCell3D();
vcell.setValFrom(col_boundary_val);
col_boundary_val += colOffset;
vcell.setValTo(col_boundary_val);
double cell_boundary_val = bb_left;
// divide rows in cells
for(int r = 0; r < cellCount; r++) {
HCell3D hcell = HCell3D();
hcell.setValFrom(cell_boundary_val);
cell_boundary_val += hOffset;
hcell.setValTo(cell_boundary_val);
hcell.cellId = hcell_id;
hcell_id++;
// hcell.upper will be determined later
double rect_boundary_val = bb_frnt;
// divide cells in layers => result: final cells
for (int i = 0; i < layerCount; i++) {
SCell scell = SCell();
scell.setValFrom(rect_boundary_val);
rect_boundary_val += sOffset;
scell.setValTo(rect_boundary_val);
scell.cellId = scell_id;
scell_id++;
// will be determined later
scell.upper = nullptr;
scell.neighbor = nullptr;
hcell.getRect().push_back(scell);
}
cellVector.push_back(hcell);
vcell.getRow().push_back(hcell);
}
columnVector.push_back(vcell);
}
// adjust boundaries by point distribution
int nbrOfPoints = points.size();
int pointsPerRow = nbrOfPoints / rowCount;
std::vector<CPoint> tmp_row_points {};
std::vector<CPoint> tmp_row_points_hcell {};
std::vector<CPoint> tmp_row_points_scell {};
int pointIdx = 0;
int point_counter = 0;
for(int colIdx = 0; colIdx < rowCount; colIdx++) { //proof rows
for(size_t dp_idx = pointIdx; dp_idx < points.size(); dp_idx++) {
CPoint rp = points[dp_idx];
tmp_row_points.push_back(rp);
point_counter ++;
if ((point_counter == pointsPerRow) || (dp_idx == points.size()-1)) {
// adjust y-boundaries
if (colIdx > 0) {
getColumnVector()[colIdx].setValFrom(
getColumnVector()[colIdx-1].getValTo());
}
double new_val_to_y;
if (dp_idx == points.size()-1) {
new_val_to_y = bb_top;
} else {
new_val_to_y = rp.y;
}
getColumnVector()[colIdx].setValTo(new_val_to_y);
getColumnVector()[colIdx].setNbrOfPoints(point_counter);
point_counter = 0;
// adjust x-boundaries
std::sort(tmp_row_points.begin(), tmp_row_points.end(),
pointComparisonX);
int pointsPerCell = tmp_row_points.size() / cellCount;
int tmpPointIdx = 0;
for(int h = 0; h < cellCount; h++) {
std::vector<HCell3D>* hcel_vec_ptr = &columnVector[colIdx].getRow();
for(size_t tmp_rp_idx = tmpPointIdx;
tmp_rp_idx < tmp_row_points.size(); tmp_rp_idx++) {
CPoint rp_t = tmp_row_points[tmp_rp_idx];
tmp_row_points_hcell.push_back(rp_t);
point_counter ++;
if((point_counter == pointsPerCell)
|| (tmp_rp_idx == tmp_row_points.size()-1)
/* || (h == cellCount-1 ) */) {
double new_val_to_x;
if ((tmp_rp_idx == tmp_row_points.size())
|| (h == cellCount-1)) {
new_val_to_x = bb_right;
} else {
new_val_to_x = rp_t.x;
}
hcel_vec_ptr->at(h).setValTo(new_val_to_x);
getCellVector()[h].setValTo(new_val_to_x);
getCellVector()[h].setNbrOfPoints(point_counter);
if(h < cellCount-1) {
hcel_vec_ptr->at(h+1).setValFrom(new_val_to_x);
getCellVector()[h+1].setValFrom(new_val_to_x);
}
point_counter = 0;
//adjust z-boundaries
std::sort(tmp_row_points_hcell.begin(),
tmp_row_points_hcell.end(), pointComparisonZ);
int pointsPerRect = tmp_row_points_hcell.size() / layerCount;
int tmpPointIdz = 0;
for(int r = 0; r < layerCount; r++) {
std::vector<SCell>* scel_vec_ptr = &cellVector[h].getRect();
for(size_t tmp_rp_idz = tmpPointIdz;
tmp_rp_idz < tmp_row_points_hcell.size(); tmp_rp_idz++) {
CPoint rp_tt = tmp_row_points_hcell[tmp_rp_idz];
tmp_row_points_scell.push_back(rp_tt);
point_counter++;
if((point_counter == pointsPerRect)
|| (tmp_rp_idz == tmp_row_points_scell.size()-1)) {
if (r > 0) {
scel_vec_ptr->at(r).setValFrom(
scel_vec_ptr->at(r-1).getValTo());
}
double new_val_to_z;
if ((tmp_rp_idz == tmp_row_points_scell.size()-1)
|| (r == layerCount-1)) {
new_val_to_z = bb_bck;
} else {
new_val_to_z = rp_t.z;
}
scel_vec_ptr->at(r).setValTo(new_val_to_z);
tmpPointIdz = tmp_rp_idz + 1;
scel_vec_ptr->at(r).setNbrOfPoints(point_counter);
tmp_row_points_scell.clear();
// Smoothing in case of odd number of points per rect
if (r+1 < layerCount) {
pointsPerCell = (tmp_row_points_hcell.size()-tmpPointIdz)
/ (layerCount-1-r);
}
point_counter = 0;
// next rect
break;
}
}
}
tmp_row_points_hcell.clear();
tmpPointIdx = tmp_rp_idx + 1;
hcel_vec_ptr->at(h).setNbrOfPoints(point_counter);
// Smoothing in case of odd number of points per cell
if (h+1 < cellCount) {
pointsPerCell = (tmp_row_points.size()-tmpPointIdx)
/ (cellCount-1-h);
}
point_counter = 0;
// next cell
break;
}
}
}
tmp_row_points.clear();
pointIdx = dp_idx + 1;
// Smoothing in case of odd number of points per row
if (colIdx+1 < rowCount) {
pointsPerRow = (points.size()-pointIdx)
/ (rowCount-1-colIdx);
}
point_counter = 0;
// one row up
break;
}
}
}
// clear aux. vectors
/*if (points.size() > 0) {
points.clear();
}*/
if (tmp_row_points.size() > 0) {
tmp_row_points.clear();
}
if(tmp_row_points_hcell.size() > 0) {
tmp_row_points_hcell.clear();
}
if(tmp_row_points_scell.size() > 0) {
tmp_row_points_scell.clear();
}
std::vector<SCell>* row_lower = nullptr;
std::vector<SCell>* row_upper = nullptr;
std::vector<SCell>* row_neighbor = nullptr;
// update cell pointer
if(rowCount > 0 && cellCount > 0 && layerCount > 0)
{
for(int c = 0; c < rowCount; c++) {
for(int h = 0; h < cellCount; h++) {
int pointToCellIdx = 0;
int pointToCellIdz = 0;
// choose exact cell above current cell in z-layer
for(int s = 0; s < layerCount; s++) {
if(c < rowCount-1) {
row_lower = &getColumnVector().at(c).getRow().at(h).getRect();
row_upper = &getColumnVector().at(c+1).getRow().at(h).getRect();
SCell* lower_cell_ptr = &row_lower->at(s);
SCell* upper_cell_ptr = &row_upper->at(pointToCellIdx);
if(lower_cell_ptr->getValFrom() < upper_cell_ptr->getValTo()) {
lower_cell_ptr->setUpper(upper_cell_ptr);
} else {
SCell* next_upper_cell_ptr;
do {
pointToCellIdx ++;
next_upper_cell_ptr = &row_upper->at(pointToCellIdx);
lower_cell_ptr->setUpper(next_upper_cell_ptr);
} while (lower_cell_ptr->getValFrom()
>= next_upper_cell_ptr->getValTo());
}
}
/* Neighbor of lower_cell_ptr
compare z-values
*/
if(h < cellCount-1) {
row_lower = &getColumnVector().at(c).getRow().at(h).getRect();
row_neighbor = &getColumnVector().at(c).getRow().at(h+1).getRect();
SCell* lower_cell_ptr = &row_lower->at(s);
SCell* neighbor_cell_ptr = &row_neighbor->at(pointToCellIdz);
if(lower_cell_ptr->getValFrom() < neighbor_cell_ptr->getValTo()) {
lower_cell_ptr->setNeighbor(neighbor_cell_ptr);
} else {
SCell* next_neighbor_cell_ptr;
do {
pointToCellIdz++;
next_neighbor_cell_ptr = &row_neighbor->at(pointToCellIdz);
lower_cell_ptr->setNeighbor(next_neighbor_cell_ptr);
} while(lower_cell_ptr->getValFrom()
>= next_neighbor_cell_ptr->getValTo());
}
}
}
}
}
}
const double min[] { boundingBox->getMinX(),
boundingBox->getMinY(), boundingBox->getMinZ() };
const double max[] { boundingBox->getMaxX(),
boundingBox->getMaxY(), boundingBox->getMaxZ() };
box.Set(true, min, max);
}
bool
pointComparisonY(CPoint p1, CPoint p2) {
return p1.y < p2.y;
}
/*
Returns centre of cuboid
*/
CPoint
getCuboidCentre(Rectangle<3>* r) {
double a = (r->getMaxY() - r->getMinY()) / (double)2;
double b = (r->getMaxX() - r->getMinX()) / (double)2;
double c = (r->getMaxZ() - r->getMinZ()) / (double)2;
CPoint r_c { (r->getMinX())+b, (r->getMinY())+a, (r->getMinZ()+c) };
return r_c;
}
/*
Check if a rectangle <3> is inside the irgrid3d bounding box
*/
bool
insideBoundingBox(Rectangle<3>* bbox, Rectangle<3>* r) {
double le = bbox->getMinX();
double ri = bbox->getMaxX();
double bo = bbox->getMinY();
double to = bbox->getMaxY();
double fr = bbox->getMinZ();
double bk = bbox->getMaxZ();
if (r->getMinX() >= le && r->getMaxX() <= ri
&& r->getMinY() >= bo && r->getMaxY() <=to
&& r->getMinZ() >= fr && r->getMaxZ() <= bk) {
return true;
}
return false;
}
void
IrregularGrid3D::processInput(Stream<Rectangle<3>> rStream) {
rStream.open();
Rectangle<3>* next = rStream.request();
while(next != 0){
if (!insideBoundingBox(boundingBox, next)) {
// rectangle (partially) outside the bounding box is discarded
next = rStream.request();
continue;
}
points.push_back(getCuboidCentre(next));
// free memory
delete next;
next = rStream.request();
}
rStream.close();
// sort point vector by y-coordinates
std::sort(points.begin(), points.end(), pointComparisonY);
}
void
IrregularGrid3D::processInputVector(std::vector<Rectangle<3>>* rVector) {
for (Rectangle<3> bbox : *rVector) {
if (!insideBoundingBox(boundingBox, &bbox)) {
// rectangle (partially) outside the bounding box is discarded
continue;
}
points.push_back(getCuboidCentre(&bbox));
}
// sort point vector by y-coordinates
std::sort(points.begin(), points.end(), pointComparisonY);
}
Rectangle<3> *
IrregularGrid3D::getBoundingBox() {
return boundingBox;
}
int
IrregularGrid3D::getRowCount() {
return rowCount;
}
int
IrregularGrid3D::getCellCount() {
return cellCount;
}
int
IrregularGrid3D::getLayerCount() {
return layerCount;
}
void
IrregularGrid3D::setColumnVector(std::vector<VCell3D> column_vect) {
this->columnVector = column_vect;
}
void
IrregularGrid3D::setCellVector(std::vector<HCell3D> cell_vect) {
this->cellVector = cell_vect;
}
std::vector<VCell3D>&
IrregularGrid3D::getColumnVector() {
return this->columnVector;
}
std::vector<HCell3D>&
IrregularGrid3D::getCellVector() {
return this->cellVector;
}
IrregularGrid3D::~IrregularGrid3D() {}
ListExpr
IrregularGrid3D::PropertyIrGrid3D()
{
ListExpr desclst = nl->TextAtom();
nl->AppendText(desclst,
"A <rectangle<3>> bounding box followed by list of rows.\n"
"A row consists of two-element list (<from> <to>) "
"followed by list of cells.\n"
"A cell consists of a"
"three-element list\n(<from> <to> <id>) "
"followed by a list of layers.\n"
"A layer consists of a four-element list\n(<from> "
"<to> <id> <ref_id> <ref2_id>.");
ListExpr formatlst = nl->TextAtom();
nl->AppendText(formatlst,
"(0.0 2.0 0.0 2.0 0.0 2.0) ((0.0 0.3) ((0.0 0.25 1) "
"((0.0 1.0 1 5 3) (1.0 2.0 2 6 4)) "
" (0.25 2.0 2) ((0.0 1.0 3 7 -1) (1.0 2.0 4 8 -1)))"
"(0.3 2.0) ((0.0 0.375 3) ((0.0 1.0 5 -1 7) "
"(1.0 2.0 6 -1 8)) (0.375 2.0 4) "
" ((0.0 1.0 7 -1 -1) (1.0 2.0 8 -1 -1))))");
return (nl->TwoElemList(
nl->FourElemList(nl->StringAtom("Signature"),
nl->StringAtom("Example Type List"),
nl->StringAtom("List Rep"),
nl->StringAtom("Example List")),
nl->FourElemList(nl->StringAtom("-> DATA"),
nl->StringAtom(IrregularGrid3D::BasicType()),
desclst,
formatlst)));
}
// Out function
ListExpr
IrregularGrid3D::OutIrGrid3D( ListExpr typeInfo, Word value ) {
IrregularGrid3D* irgrid3d = static_cast<IrregularGrid3D*>( value.addr );
if (irgrid3d != nullptr) {
Rectangle<3> * b_box = irgrid3d->getBoundingBox();
ListExpr bboxLstExpr = nl->SixElemList(
nl->RealAtom(b_box->getMinX()),
nl->RealAtom(b_box->getMaxX()),
nl->RealAtom(b_box->getMinY()),
nl->RealAtom(b_box->getMaxY()),
nl->RealAtom(b_box->getMinZ()),
nl->RealAtom(b_box->getMaxZ()));
std::vector<VCell3D>* col = &irgrid3d->getColumnVector();
ListExpr rowLstExpr = nl->Empty();
ListExpr lastRowLstExpr;
if (col->size() > 0) {
for(size_t colIdx = 0; colIdx < col->size(); colIdx++) {
VCell3D* vcell = &col->at(colIdx);
if (colIdx > 0) {
lastRowLstExpr = nl->Append(lastRowLstExpr,
nl->TwoElemList(nl->RealAtom(vcell->getValFrom()),
nl->RealAtom(vcell->getValTo())));
} else {
rowLstExpr = nl->OneElemList(
nl->TwoElemList(nl->RealAtom(vcell->getValFrom()),
nl->RealAtom(vcell->getValTo())));
lastRowLstExpr = rowLstExpr;
}
std::vector<HCell3D>* row_vect = &col->at(colIdx).getRow();
if (row_vect->size() > 0) {
ListExpr cellLstExpr;
ListExpr lastCellLstExpr;
for(size_t rowIdx = 0; rowIdx < row_vect->size(); rowIdx++) {
HCell3D* row_cell = &row_vect->at(rowIdx);
if (rowIdx > 0) {
lastCellLstExpr = nl->Append(lastCellLstExpr,
nl->ThreeElemList(nl->RealAtom(row_cell->getValFrom()),
nl->RealAtom(row_cell->getValTo()),
nl->IntAtom(row_cell->getCellId())));
} else {
cellLstExpr = nl->OneElemList(nl->ThreeElemList
(nl->RealAtom(row_cell->getValFrom()),
nl->RealAtom(row_cell->getValTo()),
nl->IntAtom(row_cell->getCellId())));
lastCellLstExpr = cellLstExpr;
}
std::vector<SCell>* cell_vect = &row_vect->at(rowIdx).getRect();
if(cell_vect->size() > 0) {
ListExpr layerLstExpr;
ListExpr lastLayerLstExpr;
for(size_t cellIdx = 0; cellIdx < cell_vect->size(); cellIdx++) {
SCell* cell_layer = &cell_vect->at(cellIdx);
if(cellIdx > 0) {
lastLayerLstExpr = nl->Append(lastLayerLstExpr,
nl->FiveElemList(nl->RealAtom(cell_layer->getValFrom()),
nl->RealAtom(cell_layer->getValTo()),
nl->IntAtom(cell_layer->getCellId()),
nl->IntAtom(cell_layer->getUpper() != nullptr
? cell_layer->getUpper()->getCellId() : -1),
nl->IntAtom(cell_layer->getNeighbor() != nullptr
? cell_layer->getNeighbor()->getCellId() : -1)
));
} else {
layerLstExpr = nl->OneElemList(nl->FiveElemList
(nl->RealAtom(cell_layer->getValFrom()),
nl->RealAtom(cell_layer->getValTo()),
nl->IntAtom(cell_layer->getCellId()),
nl->IntAtom(cell_layer->getUpper() != nullptr
? cell_layer->getUpper()->getCellId() : -1),
nl->IntAtom(cell_layer->getNeighbor() != nullptr
? cell_layer->getNeighbor()->getCellId() : -1)
));
lastLayerLstExpr = layerLstExpr;
}
}
lastCellLstExpr = nl->Append(lastCellLstExpr,layerLstExpr);
}
}
lastRowLstExpr = nl->Append(lastRowLstExpr, cellLstExpr);
}
}
}
ListExpr irgrid3dLstExpr = nl->TwoElemList(bboxLstExpr, rowLstExpr);
return irgrid3dLstExpr;
} else {
return nl->TheEmptyList();
//return (nl->SymbolAtom(Symbol::UNDEFINED()));
}
}
// In function
Word
IrregularGrid3D::InIrGrid3D( const ListExpr typeInfo, const ListExpr instance,
const int errorPos, ListExpr& errorInfo, bool& correct ) {
Word w = SetWord(Address(0));
try {
Rectangle<3>* bbox;
ListExpr bboxLstExpr;
ListExpr rowLstExpr;
if ( nl->ListLength( instance ) == 2 ) {
bboxLstExpr = nl->First(instance);
rowLstExpr = nl->Second(instance);
} else {
throw 1;
}
// fetch bounding box information from input
if (nl->ListLength( bboxLstExpr ) == 6 ) {
ListExpr left = nl->First(bboxLstExpr);
ListExpr right = nl->Second(bboxLstExpr);
ListExpr bottom = nl->Third(bboxLstExpr);
ListExpr top = nl->Fourth(bboxLstExpr);
ListExpr front = nl->Fifth(bboxLstExpr);
ListExpr back = nl->Sixth(bboxLstExpr);
if ( nl->IsAtom(left) && nl->AtomType(left) == RealType
&& nl->IsAtom(right) && nl->AtomType(right) == RealType
&& nl->IsAtom(bottom) && nl->AtomType(bottom) == RealType
&& nl->IsAtom(top) && nl->AtomType(top) == RealType
&& nl->IsAtom(front) && nl->AtomType(front) == RealType
&& nl->IsAtom(back) && nl->AtomType(back) == RealType) {
double min[3], max[3];
min[0] = nl->RealValue(left);
min[1] = nl->RealValue(bottom);
max[0] = nl->RealValue(right);
max[1] = nl->RealValue(top);
min[2] = nl->RealValue(front);
max[2] = nl->RealValue(back);
bbox = new Rectangle<3>(true, min, max);
} else {
throw 3;
}
} else {
throw 2;
}
// fetch row information from input
// temporary support structures
std::map<int, int> cellRef;
std::map<int, int> NeighbRef;
std::map<int, SCell*> cellIds;
std::vector<VCell3D> column_vec {};
std::vector<HCell3D> cell_vec {};
int row_cnt = 0;
int cell_cnt = 0;
int layer_cnt = 0;
if (nl->ListLength( rowLstExpr ) > 1 ) {
VCell3D vc;
HCell3D hc;
VCell3D* vc_ptr;
HCell3D* hc_ptr;
while(!nl->IsEmpty(rowLstExpr)) {
ListExpr lstElem = nl->First(rowLstExpr);
if ((nl->ListLength(lstElem)) == 2
&& (nl->IsAtom(nl->First(lstElem))
&& nl->IsAtom(nl->Second(lstElem))) ) {
// a two-element double list initiates a new row
row_cnt ++;
ListExpr fLst = nl->First(lstElem);
ListExpr tLst = nl->Second(lstElem);
if ( nl->AtomType(fLst) == RealType
&& nl->AtomType(tLst) == RealType) {
vc = VCell3D();
vc.setValFrom(nl->RealValue(fLst));
vc.setValTo(nl->RealValue(tLst));
column_vec.push_back(vc);
vc_ptr = &(column_vec.back());
}
} else {
ListExpr rowLstExpr = lstElem;
while(!nl->IsEmpty(rowLstExpr)) {
// cell information
ListExpr cellLstExpr = nl->First(rowLstExpr);
if (nl->ListLength( cellLstExpr ) == 3) {
// a three-element list initiates a new rectangle
ListExpr cv1Lst = nl->First(cellLstExpr);
ListExpr cv2Lst = nl->Second(cellLstExpr);
ListExpr cv3Lst = nl->Third(cellLstExpr);
if ( nl->IsAtom(cv1Lst) && nl->AtomType(cv1Lst) == RealType
&& nl->IsAtom(cv2Lst) && nl->AtomType(cv2Lst) == RealType
&& nl->IsAtom(cv3Lst) && nl->AtomType(cv3Lst) == IntType
) {
hc = HCell3D();
hc.setValFrom(nl->RealValue(cv1Lst));
hc.setValTo(nl->RealValue(cv2Lst));
hc.setCellId(nl->IntValue(cv3Lst));
// will be determined later
//hc->setUpper(nullptr);
vc_ptr->getRow().push_back(hc);
cell_vec.push_back(hc);
hc_ptr = &(vc_ptr->getRow().back());
//hc_ptr = &(cell_vec.back());
} else {
throw 5;
}
} else {
//ListExpr rowLstExpr = cellLstExpr;
while(!nl->IsEmpty(cellLstExpr)) {
ListExpr layerLstExpr = nl->First(cellLstExpr);
if(nl->ListLength( layerLstExpr ) == 5) {
// a five-element list initiates a new layer/ the whole cell
ListExpr lv1Lst = nl->First(layerLstExpr);
ListExpr lv2Lst = nl->Second(layerLstExpr);
ListExpr lv3Lst = nl->Third(layerLstExpr);
ListExpr lv4Lst = nl->Fourth(layerLstExpr);
ListExpr lv5Lst = nl->Fifth(layerLstExpr);
if(nl->IsAtom(lv1Lst) && nl->AtomType(lv1Lst) == RealType
&& nl->IsAtom(lv2Lst) && nl->AtomType(lv2Lst) == RealType
&& nl->IsAtom(lv3Lst) && nl->AtomType(lv3Lst) == IntType
&& nl->IsAtom(lv4Lst) && nl->AtomType(lv4Lst) == IntType
&& nl->IsAtom(lv5Lst) && nl->AtomType(lv5Lst) == IntType) {
SCell* sc = new SCell();
sc->setValFrom(nl->RealValue(lv1Lst));
sc->setValTo(nl->RealValue(lv2Lst));
sc->setCellId(nl->IntValue(lv3Lst));
sc->setUpper(nullptr);
sc->setNeighbor(nullptr);
hc_ptr->getRect().push_back(*sc);
int cellRefId = nl->IntValue(lv4Lst);
if (cellRefId != -1) {
cellRef.insert(std::make_pair(
((int)nl->IntValue(lv3Lst)), cellRefId));
}
cellIds.insert(std::make_pair(
((int)nl->IntValue(lv3Lst)), sc));
int NeighbRefId = nl->IntValue(lv5Lst);
if(NeighbRefId != -1) {
NeighbRef.insert(std::make_pair(
((int)nl->IntValue(lv3Lst)), NeighbRefId));
}
cellIds.insert(std::make_pair(
((int)nl->IntValue(lv3Lst)), sc));
}
}
cellLstExpr = nl->Rest(cellLstExpr);
}
}
if(cell_cnt > 0 && layer_cnt == 0) {
layer_cnt = hc_ptr->getRect().size();
}
rowLstExpr = nl->Rest(rowLstExpr);
}
}
// determine number of cells (one-time)
if (row_cnt > 0 && cell_cnt == 0) {
cell_cnt = vc_ptr->getRow().size();
}
rowLstExpr = nl->Rest(rowLstExpr);
}
} else {
throw 4;
}
// update pointer
if (row_cnt > 0 && cell_cnt > 0 && layer_cnt > 0) {
for(int colIdx = 0; colIdx < row_cnt; colIdx++) {
VCell3D* vcell = &column_vec.at(colIdx);
std::vector<HCell3D>* row_vect = &vcell->getRow();
for(int cIdx = 0; cIdx < cell_cnt; cIdx++) {
HCell3D* hcell = &(*row_vect).at(cIdx);
std::vector<SCell>* cell_vect = &hcell->getRect();
for(int lIdx = 0; lIdx < layer_cnt; lIdx++) {
SCell* scell = &(*cell_vect).at(lIdx);
if(cellRef.find(scell->getCellId()) != cellRef.end()) {
int cell_ref = cellRef.at(scell->getCellId());
if(cellIds.find(cell_ref) != cellIds.end()) {
scell->setUpper(cellIds.at(cell_ref));
}
}
if(NeighbRef.find(scell->getCellId()) != NeighbRef.end()) {
int neighb_ref = NeighbRef.at(scell->getCellId());
if(cellIds.find(neighb_ref) != cellIds.end()) {
scell->setNeighbor(cellIds.at(neighb_ref));
}
}
}
}
}
}
correct = true;
IrregularGrid3D* irgrid = new IrregularGrid3D(*bbox,
row_cnt, cell_cnt, layer_cnt);
irgrid->setColumnVector(column_vec);
irgrid->setCellVector(cell_vec);
irgrid->box = *bbox;
w.addr = irgrid;
return w;
} catch (int e) {
correct = false;
cmsg.inFunError("Expecting a irgrid3d list representation. Exit code "
+ std::to_string(e));
return w;
}
}
// This function checks whether the type constructor is applied correctly.
bool
IrregularGrid3D::KindCheckIrGrid3D( ListExpr type, ListExpr& errorInfo )
{
return (nl->IsEqual( type, IrregularGrid3D::BasicType() ));
}
// Close -function
void
IrregularGrid3D::CloseIrGrid3D( const ListExpr typeInfo, Word& w )
{
delete (IrregularGrid3D *)w.addr;
w.addr = 0;
}
// Clone function
Word
IrregularGrid3D::CloneIrGrid3D( const ListExpr typeInfo, const Word& w )
{
IrregularGrid3D *g = new IrregularGrid3D( *((IrregularGrid3D *)w.addr) );
return SetWord( g );
}
// Create function
Word
IrregularGrid3D::CreateIrGrid3D( const ListExpr typeInfo )
{
return SetWord( new IrregularGrid3D() );
}
// Delete function
void
IrregularGrid3D::DeleteIrGrid3D( const ListExpr typeInfo, Word& w )
{
delete (IrregularGrid3D *)w.addr;
w.addr = 0;
}
// SizeOf function
int
IrregularGrid3D::SizeOfIrGrid3D()
{
return sizeof(IrregularGrid3D);
}
bool IrregularGrid3D::OpenIrGrid3D( SmiRecord& valueRecord, size_t& offset,
const ListExpr typeInfo, Word& value){
size_t size = sizeof(int);
size_t sizeD = sizeof(double);
int xr = 0, yb = 0, yt = 0;
size_t cols = 0, rows = 0, cellsize = 0;
std::vector<VCell3D> column_vec {};
std::vector<HCell3D> cell_vec {};
VCell3D vc;
HCell3D hc;
VCell3D* vc_ptr;
HCell3D* hc_ptr;
std::map<int, int> cellRef;
std::map<int, int> NeighbRef;
std::map<int, SCell> cellIds;
double vf = 0.0, vt = 0.0; //column values
double rvf = 0.0, rvt = 0.0; // row values
double cvf = 0.0, cvt = 0.0; // cell values
int rid = 0, cellid = 0, cellu = 0, celln = 0;
double xmin=0.0, xmax=0.0, ymin=0.0, ymax=0.0, zmin=0.0, zmax=0.0;
bool ok = true;
ok = ok && valueRecord.Read( &xmin, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &xmax, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &ymin, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &ymax, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &zmin, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &zmax, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &xr, size, offset );
offset += size;
ok = ok && valueRecord.Read( &yb, size, offset );
offset += size;
ok = ok && valueRecord.Read( &yt, size, offset );
offset += size;
// colsize
ok = ok && valueRecord.Read( &cols, sizeof(size_t), offset );
offset += sizeof(size_t);
for(size_t i = 0; i < cols; i++)
{
vc = VCell3D();
ok = ok && valueRecord.Read( &vf, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &vt, sizeD, offset );
offset += sizeD;
vc.setValFrom(vf);
vc.setValTo(vt);
column_vec.push_back(vc);
vc_ptr = &(column_vec.back());
//rowsize
ok = ok && valueRecord.Read( &rows, sizeof(size_t), offset );
offset += sizeof(size_t);
for(size_t j = 0; j < rows; j++)
{
hc = HCell3D();
ok = ok && valueRecord.Read( &rvf, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &rvt, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &rid, size, offset );
offset += size;
hc.setValFrom(rvf);
hc.setValTo(rvt);
hc.setCellId(rid);
vc_ptr->getRow().push_back(hc);
cell_vec.push_back(hc);
hc_ptr = &(vc_ptr->getRow().back());
ok = ok && valueRecord.Read( &cellsize, sizeof(size_t), offset );
offset += sizeof(size_t);
for(size_t k = 0; k < cellsize; k++)
{
ok = ok && valueRecord.Read( &cvf, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &cvt, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Read( &cellid, size, offset );
offset += size;
ok = ok && valueRecord.Read( &cellu, size, offset );
offset += size;
ok = ok && valueRecord.Read( &celln, size, offset );
offset += size;
SCell sc = SCell();
sc.setValFrom(cvf);
sc.setValTo(cvt);
sc.setCellId(cellid);
sc.setUpper(nullptr);
sc.setNeighbor(nullptr);
hc_ptr->getRect().push_back(sc);
int cellRefId = cellu;
if (cellRefId != -1) {
cellRef.insert(std::make_pair(
cellid, cellRefId));
}
cellIds.insert(std::make_pair(
cellid, sc));
int NeighbRefId = celln;
if(NeighbRefId != -1) {
NeighbRef.insert(std::make_pair(
cellid, NeighbRefId));
}
cellIds.insert(std::make_pair(
cellid, sc));
}
}
}
// update pointer
if (xr > 0 && yb > 0 && yt > 0) {
for(int colIdx = 0; colIdx < xr; colIdx++) {
VCell3D* vcell = &column_vec.at(colIdx);
std::vector<HCell3D>* row_vect = &vcell->getRow();
for(int cIdx = 0; cIdx < yb; cIdx++) {
HCell3D* hcell = &(*row_vect).at(cIdx);
std::vector<SCell>* cell_vect = &hcell->getRect();
for(int lIdx = 0; lIdx < yt; lIdx++) {
SCell* scell = &(*cell_vect).at(lIdx);
if(cellRef.find(scell->getCellId()) != cellRef.end()) {
int cell_ref = cellRef.at(scell->getCellId());
if(cellIds.find(cell_ref) != cellIds.end()) {
scell->setUpper(&cellIds.at(cell_ref));
}
}
if(NeighbRef.find(scell->getCellId()) != NeighbRef.end()) {
int neighb_ref = NeighbRef.at(scell->getCellId());
if(cellIds.find(neighb_ref) != cellIds.end()) {
scell->setNeighbor(&cellIds.at(neighb_ref));
}
}
}
}
}
}
const double min[] { xmin, ymin, zmin };
const double max[] { xmax, ymax, zmax };
Rectangle<3> *bbox = new Rectangle<3>(true, min, max);
IrregularGrid3D* irgrid = new IrregularGrid3D(*bbox,
xr, yb, yt);
irgrid->setColumnVector(column_vec);
irgrid->setCellVector(cell_vec);
irgrid->box = *bbox;
value.addr = irgrid;
return ok;
}
bool IrregularGrid3D::SaveIrGrid3D(SmiRecord& valueRecord, size_t& offset,
const ListExpr typeInfo, Word& value) {
IrregularGrid3D* r = static_cast<IrregularGrid3D*>( value.addr );
size_t size = sizeof(int);
size_t sizeD = sizeof(double);
bool ok = true;
double minx = r->box.getMinX();
double maxx = r->box.getMaxX();
double miny = r->box.getMinY();
double maxy = r->box.getMaxY();
double minz = r->box.getMinZ();
double maxz = r->box.getMaxZ();
ok = ok && valueRecord.Write(&minx, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&maxx, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&miny, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&maxy, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&minz, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&maxz, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&r->rowCount, size, offset );
offset += size;
ok = ok && valueRecord.Write(&r->cellCount, size, offset );
offset += size;
ok = ok && valueRecord.Write(&r->layerCount, size, offset );
offset += size;
std::vector<VCell3D>* col = &r->getColumnVector();
size_t cols = col->size();
if (col->size() > 0) {
ok = ok && valueRecord.Write(&cols, sizeof(size_t), offset );
offset += sizeof(size_t);
for(size_t colIdx = 0; colIdx < col->size(); colIdx++) {
VCell3D* vcell = &col->at(colIdx);
double vf = vcell->getValFrom();
double vt = vcell->getValTo();
ok = ok && valueRecord.Write(&vf, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&vt, sizeD, offset );
offset += sizeD;
std::vector<HCell3D>* row_vect = &col->at(colIdx).getRow();
size_t rows = row_vect->size();
if (row_vect->size() > 0) {
ok = ok && valueRecord.Write(&rows, sizeof(size_t), offset );
offset += sizeof(size_t);
for(size_t rowIdx = 0; rowIdx < row_vect->size(); rowIdx++) {
HCell3D* row_cell = &row_vect->at(rowIdx);
double rvf = row_cell->getValFrom();
double rvt = row_cell->getValTo();
int ri = row_cell->getCellId();
ok = ok && valueRecord.Write(&rvf, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&rvt, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&ri, size, offset );
offset += size;
std::vector<SCell>* cell_vect = &row_vect->at(rowIdx).getRect();
size_t cellsize = cell_vect->size();
if(cell_vect->size() > 0) {
ok = ok && valueRecord.Write(&cellsize, sizeof(size_t), offset );
offset += sizeof(size_t);
for(size_t cellIdx = 0; cellIdx < cell_vect->size(); cellIdx++) {
SCell* cell_layer = &cell_vect->at(cellIdx);
double cvf = cell_layer->getValFrom();
double cvt = cell_layer->getValTo();
int ci = cell_layer->getCellId();
int cu = cell_layer->getUpper() != nullptr
? cell_layer->getUpper()->getCellId() : -1;
int cn = cell_layer->getNeighbor() != nullptr
? cell_layer->getNeighbor()->getCellId() : -1;
ok = ok && valueRecord.Write(&cvf, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&cvt, sizeD, offset );
offset += sizeD;
ok = ok && valueRecord.Write(&ci, size, offset );
offset += size;
ok = ok && valueRecord.Write(&cu, size, offset );
offset += size;
ok = ok && valueRecord.Write(&cn, size, offset );
offset += size;
}
}
}
}
}
}
return ok;
}
/*
Type mapping function ~IrGrid3dFeedTypeMap~
It is used for the ~feed~ operator.
*/
ListExpr
IrregularGrid3D::IrGrid3dFeedTypeMap( ListExpr args )
{
if(nl->HasLength(args, 1)) {
ListExpr first = nl->First(args);
if (IrregularGrid3D::checkType(first)) {
ListExpr resAttrList = nl->ThreeElemList(
nl->TwoElemList(
nl->SymbolAtom("Id"),
nl->SymbolAtom(CcInt::BasicType())),
nl->TwoElemList(
nl->SymbolAtom("Count"),
nl->SymbolAtom(CcInt::BasicType())),
nl->TwoElemList(
nl->SymbolAtom("Cell3D"),
nl->SymbolAtom(Rectangle<3>::BasicType())));
return nl->TwoElemList(listutils::basicSymbol<Stream<Tuple>>(),
nl->TwoElemList(
listutils::basicSymbol<Tuple>(),
resAttrList));
}
}
const std::string errMsg = "The following argument is expected:"
" irgrid3d";
return listutils::typeError(errMsg);
}
// for value mapping function of ~feed~ operator
struct IrGrid3DTupleInfo
{
std::vector<CellInfo3D*> cell_info_vect;
unsigned int currentTupleIdx;
ListExpr numTupleTypeList;
void init(IrregularGrid3D *irgrid3d_in) {
currentTupleIdx = 0;
cell_info_vect = IrregularGrid3D::getCellInfoVector(irgrid3d_in);
ListExpr tupleTypeLst = nl->TwoElemList(
nl->SymbolAtom(Tuple::BasicType()),
nl->ThreeElemList(
nl->TwoElemList(
nl->SymbolAtom("Id"),
nl->SymbolAtom(CcInt::BasicType())),
nl->TwoElemList(
nl->SymbolAtom("Count"),
nl->SymbolAtom(CcInt::BasicType())),
nl->TwoElemList(
nl->SymbolAtom("Cell3D"),
nl->SymbolAtom(Rectangle<3>::BasicType()))));
SecondoCatalog* sc = SecondoSystem::GetCatalog();
numTupleTypeList = sc->NumericType(tupleTypeLst);
}
TupleType* getTupleType() {
TupleType *tupleType = new TupleType(numTupleTypeList);
return tupleType;
}
Tuple* getNext(TupleType *ttype) {
if (currentTupleIdx < cell_info_vect.size()) {
CellInfo3D * cell_info = cell_info_vect.at(currentTupleIdx);
int tp_p1 = cell_info->cellId;
int tp_p2 = cell_info->statNbrOfPoints;
Rectangle<3> tp_p3 = *cell_info->cell;
Tuple *tuple = new Tuple(ttype);
tuple->PutAttribute(0, new CcInt(true, tp_p1));
tuple->PutAttribute(1, new CcInt(true, tp_p2));
tuple->PutAttribute(2, new Rectangle<3> (tp_p3));
currentTupleIdx++;
return tuple;
} else {
return nullptr;
}
}
};
/*
Value mapping function of operator ~feed~
*/
int
IrregularGrid3D::IrGrid3dValueMapFeed( Word* args, Word& result, int message,
Word& local, Supplier s ) {
IrregularGrid3D *input_irgrid3d_ptr =
static_cast<IrregularGrid3D*>( args[0].addr );
IrGrid3DTupleInfo* tp_info = static_cast<IrGrid3DTupleInfo*>(local.addr);
TupleType* tupleType = nullptr;
Tuple* tuple = nullptr;
switch (message) {
case OPEN: {
tp_info = new IrGrid3DTupleInfo();
tp_info->init(input_irgrid3d_ptr);
local.addr = tp_info;
return 0;
}
case REQUEST: {
if (local.addr) {
tp_info = ((IrGrid3DTupleInfo*)local.addr);
tupleType = tp_info->getTupleType();
} else {
return CANCEL;
}
// get next tuple
tuple = tp_info->getNext(tupleType);
if (tuple != nullptr) {
result.addr = tuple;
return YIELD;
} else {
result.addr = 0;
return CANCEL;
}
}
case CLOSE: {
if (local.addr) {
tp_info = ((IrGrid3DTupleInfo*)local.addr);
delete tp_info;
local.addr = 0;
}
return 0;
}
}
return -1;
}
/*
Type mapping function ~IrGrid3dCellnosTypeMap~
It is used for the ~cellnos\_ir~ operator.
*/
ListExpr
IrregularGrid3D::IrGrid3dCellnosTypeMap( ListExpr args )
{
if(nl->HasLength(args, 2)) {
ListExpr first = nl->First(args);
ListExpr second = nl->Second(args);
if (IrregularGrid3D::checkType(first) && Rectangle<3>::checkType(second)) {
return nl->SymbolAtom(collection::IntSet::BasicType());
}
}
const std::string errMsg = "The following two arguments are expected:"
" irgrid3d x rect<3>";
return listutils::typeError(errMsg);
}
ListExpr
IrregularGrid3D::IrGrid3dSCCTypeMap( ListExpr args )
{
if(nl->HasLength(args, 4)) {
ListExpr first = nl->First(args);
ListExpr second = nl->Second(args);
ListExpr third = nl->Third(args);
ListExpr fourth = nl->Fourth(args);
if (IrregularGrid3D::checkType(first) && Rectangle<3>::checkType(second)
&& Rectangle<3>::checkType(third) && CcInt::checkType(fourth)) {
return nl->SymbolAtom(CcBool::BasicType());
}
}
const std::string errMsg = "The following four arguments are expected:"
" irgrid3d x rect3d x rect3 x int";
return listutils::typeError(errMsg);
}
ListExpr
IrregularGrid3D::IrGrid3dGetCellTypeMap( ListExpr args )
{
if(nl->HasLength(args, 2)) {
ListExpr first = nl->First(args);
ListExpr second = nl->Second(args);
if (IrregularGrid3D::checkType(first) && CcInt::checkType(second)) {
return nl->SymbolAtom(Rectangle<3>::BasicType());
}
}
const std::string errMsg = "The following two arguments are expected:"
" irgrid3d x int";
return listutils::typeError(errMsg);
}
ListExpr
IrregularGrid3D::IrGrid3dBBoxTypeMap( ListExpr args )
{
if(nl->HasLength(args, 1)) {
ListExpr first = nl->First(args);
if (Stream<Rectangle<3>>::checkType(first)) {
return nl->SymbolAtom(Rectangle<3>::BasicType());
}
}
const std::string errMsg = "The following argument is expected:"
" stream<rect<3>>";
return listutils::typeError(errMsg);
}
ListExpr
IrregularGrid3D::IrGrid2dBBoxTypeMap( ListExpr args )
{
if(nl->HasLength(args, 1)) {
ListExpr first = nl->First(args);
if (Stream<Rectangle<2>>::checkType(first)) {
return nl->SymbolAtom(Rectangle<2>::BasicType());
}
}
const std::string errMsg = "The following argument is expected:"
" stream<rect>";
return listutils::typeError(errMsg);
}
template <class C>
bool
InCell(C cell, double val) {
return (val >= cell.getValFrom()
&& val < cell.getValTo());
}
template <class C>
bool
GtCell(C cell, double val) {
return (cell.getValFrom() >= val);
}
template <class C>
int
CellBS(const std::vector<C>* c_vec, int start, int end, const double val) {
if (start > end) {
return -1;
}
const int mid = start + ((end - start) / 2);
if (InCell(c_vec->at(mid), val)) {
return mid;
} else if (GtCell(c_vec->at(mid), val)) {
return CellBS(c_vec, start, mid-1, val);
}
return CellBS(c_vec, mid+1, end, val);
}
/*
returns cellnumbers of cells which a given
cuboid intersects
*/
void
cellNum(IrregularGrid3D *input_irgrid3d_ptr,
Rectangle<3> *search_window_ptr, std::set<int> *cell_ids){
std::vector<VCell3D>* col = &input_irgrid3d_ptr->getColumnVector();
double le = search_window_ptr->getMinX();
double ri = search_window_ptr->getMaxX();
double bo = search_window_ptr->getMinY();
double to = search_window_ptr->getMaxY();
double fr = search_window_ptr->getMinZ();
double ba = search_window_ptr->getMaxZ();
// check for 3d
if(le == ri || bo == to || fr == ba)
{
//cell_ids->insert(0);
return;
}
int pos_bo = CellBS(col, 0, col->size(), bo);
if (pos_bo != -1) {
VCell3D vCell = col->at(pos_bo);
std::vector<HCell3D>* row = &vCell.getRow();
int pos_le = CellBS(row, 0, row->size(), le);
if (pos_le != -1) {
HCell3D hcell = row->at(pos_le);
std::vector<SCell>* cells = &hcell.getRect();
int pos_fr = CellBS(cells, 0, cells->size(), fr);
if(pos_fr != -1) {
// collect ids
unsigned int cellIdx = pos_fr;
int pos_left = pos_le;
SCell begin_i = cells->at(cellIdx); // first cell
while (cellIdx < cells->size()) {
SCell i = cells->at(cellIdx);
cell_ids->insert(i.getCellId());
if((ba >= i.getValFrom() && ba <= i.getValTo())
|| (cellIdx == cells->size()-1 && ba >= i.getValFrom())) {
SCell fi = cells->at(pos_fr);
if(ri > hcell.getValTo() && fi.getNeighbor() != nullptr) {
hcell = row->at(++pos_le);
cells = &hcell.getRect();
SCell* u = fi.getNeighbor();
int nbr_cpr = input_irgrid3d_ptr->getLayerCount();
int cid_pos = (u->getCellId()) % nbr_cpr;
pos_fr = cid_pos == 0 ? nbr_cpr-1 : cid_pos-1;
cellIdx = pos_fr-1;
} else if (ri <= hcell.getValTo() ||
fi.getNeighbor() == nullptr) {
if (to > vCell.getValTo() && begin_i.getUpper() != nullptr) {
SCell* up = begin_i.getUpper();
int nbr_cpr = input_irgrid3d_ptr->getLayerCount();
int cid_pos = (up->getCellId()) % nbr_cpr;
pos_fr = cid_pos == 0 ? nbr_cpr-1 : cid_pos-1;
cellIdx = pos_fr-1;
int pos_test = pos_bo +1;
if(pos_test < (int)col->size()) {
row = &col->at(++pos_bo).getRow(); // one row up
hcell = row->at(pos_left);
cells = &hcell.getRect();
begin_i = cells->at(pos_fr);
// in case there is another neighbor in the new row
pos_le = pos_left;
}
} else if (to <= vCell.getValTo() &&
begin_i.getUpper() == nullptr) {
break;
} else { break; }
}
}
cellIdx++;
}
}
}
}
}
/*
Value mapping function of operator ~cellnos\_ir~
*/
int
IrregularGrid3D::IrGrid3dValueMapCellnos( Word* args, Word& result, int message,
Word& local, Supplier s ) {
IrregularGrid3D *input_irgrid3d_ptr
= static_cast<IrregularGrid3D*>( args[0].addr );
Rectangle<3> *search_window_ptr
= static_cast<Rectangle<3>*>( args[1].addr );
if (input_irgrid3d_ptr != nullptr && search_window_ptr != nullptr) {
std::set<int> cell_ids;
result = qp->ResultStorage(s);
collection::IntSet* res = (collection::IntSet*) result.addr;
Rectangle<3> * b_box = input_irgrid3d_ptr->getBoundingBox();
if(b_box->getMinX() > b_box->getMaxX() ||
b_box->getMinY() > b_box->getMaxY()
||b_box->getMinZ() > b_box->getMaxZ())
{
return 0;
}
if (!search_window_ptr->Intersects(*b_box)) {
cell_ids.insert(0);
res->setTo(cell_ids);
return 0;
}
// 'truncate' search window in case of partial cutting
if (!b_box->Contains(*search_window_ptr)) {
search_window_ptr = new Rectangle<3>(
search_window_ptr->Intersection(*b_box));
cell_ids.insert(0);
}
cellNum(input_irgrid3d_ptr, search_window_ptr, &cell_ids);
res->setTo(cell_ids);
return 0;
}
return -1;
}
/*
Value mapping function of operator ~scc\_3d~
*/
int
IrregularGrid3D::IrGrid3dValueMapSCC( Word* args, Word& result, int message,
Word& local, Supplier s ) {
IrregularGrid3D *input_irgrid3d_ptr
= static_cast<IrregularGrid3D*>( args[0].addr );
Rectangle<3> *search_window_ptr
= static_cast<Rectangle<3>*>( args[1].addr );
Rectangle<3> *search_window_ptr_2
= static_cast<Rectangle<3>*>( args[2].addr );
CcInt* cellno_ptr = static_cast<CcInt*>(args[3].addr);
int cellno = cellno_ptr->GetIntval();
if (input_irgrid3d_ptr != nullptr && search_window_ptr != nullptr
&& search_window_ptr_2 != nullptr) {
std::set<int> cell_ids;
std::set<int> cell_ids_2;
Rectangle<3>* b_box = input_irgrid3d_ptr->getBoundingBox();
if (!search_window_ptr->Intersects(*b_box)
|| !search_window_ptr_2->Intersects(*b_box)) {
return 0;
}
// 'truncate' search window in case of partial cutting
if (!b_box->Contains(*search_window_ptr)) {
search_window_ptr = new Rectangle<3>(
search_window_ptr->Intersection(*b_box));
cell_ids.insert(0);
}
if (!b_box->Contains(*search_window_ptr_2)) {
search_window_ptr_2 = new Rectangle<3>(
search_window_ptr_2->Intersection(*b_box));
cell_ids_2.insert(0);
}
result = qp->ResultStorage( s );
CcBool *res = (CcBool*) result.addr;
bool boolval = false;
cellNum(input_irgrid3d_ptr, search_window_ptr, &cell_ids);
cellNum(input_irgrid3d_ptr, search_window_ptr_2, &cell_ids_2);
std::vector<int> v(sizeof(cell_ids)+ sizeof(cell_ids_2));
std::vector<int>::iterator it;
it=std::set_intersection (cell_ids.begin(), cell_ids.end(),
cell_ids_2.begin(), cell_ids_2.end(), v.begin());
v.resize(it-v.begin());
if(v.empty()) {
//no intersection between rectangles
res->Set( true, boolval);
return 0;
}
if(v.at(0) == cellno)
{
boolval = true;
res->Set( true, boolval);
return 0;
}
res->Set( true, boolval);
return 0;
}
return -1;
}
/*
Value Mapping function of operator ~getCell~
*/
int
IrregularGrid3D::IrGrid3dValueMapGetCell(Word* args, Word& result, int message,
Word& local, Supplier s)
{
IrregularGrid3D *input_irgrid3d_ptr
= static_cast<IrregularGrid3D*>( args[0].addr );
CcInt* cellno_ptr = static_cast<CcInt*>(args[1].addr);
int cellno = cellno_ptr->GetIntval();
if (input_irgrid3d_ptr != nullptr)
{
result = qp->ResultStorage( s );
Rectangle<3> *res = (Rectangle<3>*) result.addr;
std::vector<VCell3D>* column = &input_irgrid3d_ptr->getColumnVector();
for(size_t i = 0; i < column->size(); i++)
{
VCell3D vCell = column->at(i);
std::vector<HCell3D>* row = &vCell.getRow();
for(size_t ii=0; ii < row->size(); ii++)
{
HCell3D hCell = row->at(ii);
std::vector<SCell>* cell = &hCell.getRect();
for(size_t iii=0; iii < cell->size(); iii++)
{
SCell c = cell->at(iii);
if(cellno == c.getCellId())
{
double min[3], max[3];
min[0] = hCell.getValFrom();
min[1] = vCell.getValFrom();
min[2] = c.getValFrom();
max[0] = hCell.getValTo();
max[1] = vCell.getValTo();
max[2] = c.getValTo();
res->Set(true, min, max);
return 0;
}
}
}
}
}
return -1;
}
/*
Value mapping function of operator ~bbox\_grid~
*/
int
IrregularGrid3D::IrGrid2dValueMapBBox( Word* args, Word& result, int message,
Word& local, Supplier s ) {
Stream<Rectangle<2>> rStream(args[0]);
result = qp->ResultStorage(s);
Rectangle<2>* res = (Rectangle<2>*) result.addr;
rStream.open();
Rectangle<2>* next = rStream.request();
if(next != 0) {
double min[2], max[2];
min[0] = next->getMinX();
min[1] = next->getMinY();
max[0] = next->getMaxX();
max[1] = next->getMaxY();
next = rStream.request();
while(next != 0){
if(next->getMinX() < min[0])
{ min[0] = next->getMinX(); }
if(next->getMinY() < min[1])
{ min[1] = next->getMinY(); }
if(next->getMaxX() > max[0])
{ max[0] = next->getMaxX(); }
if(next->getMaxY() > max[1])
{ max[1] = next->getMaxY(); }
next = rStream.request();
}
rStream.close();
res->Set(true, min, max);
return 0;
}
return -1;
}
/*
Value mapping function of operator ~bbox\_grid3d~
*/
int
IrregularGrid3D::IrGrid3dValueMapBBox( Word* args, Word& result, int message,
Word& local, Supplier s ) {
Stream<Rectangle<3>> rStream(args[0]);
result = qp->ResultStorage(s);
Rectangle<3>* res = (Rectangle<3>*) result.addr;
rStream.open();
Rectangle<3>* next = rStream.request();
if(next != 0) {
double min[3], max[3];
min[0] = next->getMinX();
min[1] = next->getMinY();
min[2] = next->getMinZ();
max[0] = next->getMaxX();
max[1] = next->getMaxY();
max[2] = next->getMaxZ();
next = rStream.request();
while(next != 0){
if(next->getMinX() < min[0])
{ min[0] = next->getMinX(); }
if(next->getMinY() < min[1])
{ min[1] = next->getMinY(); }
if(next->getMinZ() < min[2])
{ min[2] = next->getMinZ(); };
if(next->getMaxX() > max[0])
{ max[0] = next->getMaxX(); }
if(next->getMaxY() > max[1])
{ max[1] = next->getMaxY(); }
if(next->getMaxZ() > max[2])
{ max[2] = next->getMaxZ(); }
next = rStream.request();
}
rStream.close();
res->Set(true, min, max);
return 0;
}
return -1;
}
Reference in New Issue View Git Blame Copy Permalink