921 lines
20 KiB
C++
921 lines
20 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
|
|
----
|
|
|
|
//paragraph [1] title: [{\Large \bf ] [}]
|
|
|
|
[1] SemanticTrajectory Algebra
|
|
Author: Catherine Higgins
|
|
|
|
1 Overview
|
|
|
|
2 Defines, includes, and constants
|
|
|
|
*/
|
|
|
|
#ifndef __SEMANTIC_TRAJECTORY_ALGEBRA_H__
|
|
#define __SEMANTIC_TRAJECTORY_ALGEBRA_H__
|
|
|
|
|
|
#include "../../Tools/Flob/DbArray.h"
|
|
/* Needed for Flob Array */
|
|
#include "../../Tools/Flob/Flob.h"
|
|
/* Needed for Flob */
|
|
#include "Algebras/Rectangle/RectangleAlgebra.h"
|
|
/* for bounding box */
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <cmath>
|
|
#include <float.h>
|
|
/* This is needed for DBL_MAX */
|
|
#include "StringUtils.h"
|
|
/* This is needed to tokenized strings */
|
|
#include "Algebras/Geoid/Geoid.h"
|
|
#include <vector>
|
|
namespace semtraj {
|
|
|
|
/*
|
|
3 Structs for Class Batch and SemanticTrajectory
|
|
|
|
3.1 struct Coordinate
|
|
|
|
*/
|
|
|
|
struct Coordinate
|
|
{
|
|
Coordinate() {}
|
|
/* Do not use this constructor */
|
|
Coordinate( double xcoord, double ycoord ):
|
|
x( xcoord ), y( ycoord )
|
|
{}
|
|
|
|
Coordinate(const Coordinate& c) : x(c.x), y(c.y) {}
|
|
|
|
Coordinate& operator=(const Coordinate& c){
|
|
x = c.x;
|
|
y = c.y;
|
|
return *this;
|
|
}
|
|
|
|
~Coordinate(){}
|
|
|
|
double x;
|
|
double y;
|
|
};
|
|
|
|
/*
|
|
3.2 Struct TextData
|
|
|
|
*/
|
|
/*
|
|
Struct for holding a Text data relating to each coordinate point
|
|
Used to hold position of where each string begins in a Flob
|
|
Flob contains each string associated to each coordinate point
|
|
|
|
*/
|
|
|
|
struct TextData
|
|
{
|
|
SmiSize Offset;
|
|
SmiSize Length;
|
|
};
|
|
|
|
|
|
/*
|
|
3.3 Struct Cell
|
|
|
|
*/
|
|
|
|
/*
|
|
Holds the coordinates of data points in a gridcell2D
|
|
Used for the trajectory pruning (divide and conquer)
|
|
|
|
*/
|
|
struct Cell
|
|
{
|
|
Cell() {}
|
|
/* Do not use this constructor. */
|
|
|
|
Cell( int32_t id, int32_t x, int32_t y ):
|
|
tripId( id), origx( x ), origy( y )
|
|
{}
|
|
|
|
Cell(const Cell& c) :
|
|
tripId( c.tripId),
|
|
origx( c.origx ),
|
|
origy( c.origy ) {}
|
|
|
|
Cell& operator=(const Cell& c){
|
|
tripId = c.tripId;
|
|
origx = c.origx;
|
|
origy = c.origy;
|
|
return *this;
|
|
}
|
|
|
|
int32_t GetX() { return origx; }
|
|
int32_t GetY() { return origy; }
|
|
int32_t GetId() { return tripId; }
|
|
~Cell(){}
|
|
|
|
int32_t tripId;
|
|
int32_t origx;
|
|
int32_t origy;
|
|
};
|
|
|
|
/*
|
|
3.4 Struct WordST
|
|
|
|
*/
|
|
/*
|
|
Struct for textual summary
|
|
Holds the index number of a word and it's frequency
|
|
|
|
*/
|
|
|
|
struct WordST
|
|
{
|
|
WordST() {}
|
|
/* Do not use this constructor. */
|
|
|
|
WordST( int32_t id, int32_t count ):
|
|
indexId( id), count( count )
|
|
{}
|
|
|
|
WordST(const WordST& w) :
|
|
indexId( w.indexId),
|
|
count( w.count )
|
|
{}
|
|
|
|
WordST& operator=(const WordST& w){
|
|
indexId = w.indexId;
|
|
count = w.count;
|
|
return *this;
|
|
}
|
|
|
|
int32_t GetIdxId() { return indexId; }
|
|
int32_t GetCount() { return count; }
|
|
~WordST(){}
|
|
|
|
int32_t indexId;
|
|
int32_t count;
|
|
SmiSize Offset;
|
|
SmiSize Length;
|
|
|
|
};
|
|
|
|
/*
|
|
3.5 Struct BatchGroup
|
|
|
|
*/
|
|
/*
|
|
Struct for batch grouping operator batche
|
|
|
|
*/
|
|
|
|
struct BatchGroup
|
|
{
|
|
BatchGroup() {}
|
|
/* Do not use this constructor. */
|
|
|
|
BatchGroup(Rectangle<2> mbr2):
|
|
mbr(mbr2)
|
|
{
|
|
}
|
|
|
|
BatchGroup(const BatchGroup& b) :
|
|
mbr(b.mbr)
|
|
{}
|
|
|
|
BatchGroup& operator=(const BatchGroup& b){
|
|
mbr = b.mbr;
|
|
return *this;
|
|
}
|
|
bool addnewMBR(Rectangle<2> mbr2)
|
|
{
|
|
mbr = mbr.Union(mbr2);
|
|
return true;
|
|
}
|
|
|
|
Rectangle<2> GetMBR()
|
|
{
|
|
return mbr;
|
|
}
|
|
/* Search for ID */
|
|
|
|
~BatchGroup(){}
|
|
|
|
Rectangle<2> mbr;
|
|
};
|
|
|
|
/*
|
|
3.6 Struct BatchWord
|
|
|
|
*/
|
|
/*
|
|
Struct to hold the batch summary for words
|
|
Works in conjunction with batchwords_Flob flob
|
|
Part of the ST component
|
|
|
|
*/
|
|
|
|
|
|
struct BatchWord
|
|
{
|
|
BatchWord() {}
|
|
/*
|
|
Do not use this constructor.
|
|
|
|
*/
|
|
|
|
BatchWord( int32_t id, int32_t count ):
|
|
indexId( id), count( count )
|
|
{}
|
|
|
|
BatchWord(const BatchWord& w) :
|
|
indexId( w.indexId),
|
|
count( w.count )
|
|
{}
|
|
|
|
BatchWord& operator=(const BatchWord& w){
|
|
indexId = w.indexId;
|
|
count = w.count;
|
|
return *this;
|
|
}
|
|
|
|
int32_t GetIdxId() { return indexId; }
|
|
int32_t GetCount() { return count; }
|
|
~BatchWord(){}
|
|
|
|
int32_t indexId;
|
|
int32_t count;
|
|
SmiSize Offset;
|
|
SmiSize Length;
|
|
|
|
};
|
|
|
|
/*
|
|
3.7 Struct Trip
|
|
|
|
*/
|
|
|
|
/*
|
|
Struct to hold the trip summary information
|
|
|
|
*/
|
|
|
|
struct Trip
|
|
{
|
|
Trip() {}
|
|
|
|
Trip( int dummy
|
|
):
|
|
id(0),
|
|
begin_idxCoords(0),
|
|
end_idxCoords(0),
|
|
begin_idxSumWords(0),
|
|
end_idxSumWords(0),
|
|
begin_idxCells(0),
|
|
end_idxCells(0),
|
|
bbox(0)
|
|
{}
|
|
|
|
Trip(const Trip& t) :
|
|
id( t.id),
|
|
begin_idxCoords(t.begin_idxCoords),
|
|
end_idxCoords(t.end_idxCoords),
|
|
begin_idxSumWords(t.begin_idxSumWords),
|
|
end_idxSumWords(t.end_idxSumWords),
|
|
begin_idxCells(t.begin_idxCells),
|
|
end_idxCells(t.end_idxCells),
|
|
bbox(t.bbox)
|
|
{}
|
|
|
|
Trip& operator=(const Trip& t)
|
|
{
|
|
id = t.id;
|
|
begin_idxCoords = t.begin_idxCoords;
|
|
end_idxCoords = t.end_idxCoords;
|
|
begin_idxSumWords = t.begin_idxSumWords;
|
|
end_idxSumWords = t.end_idxSumWords;
|
|
begin_idxCells = t.begin_idxCells;
|
|
end_idxCells = t.end_idxCells;
|
|
bbox = t.bbox;
|
|
return *this;
|
|
}
|
|
|
|
int GetId() { return id; }
|
|
void SetId(int newid) { id = newid; }
|
|
|
|
int GetStartCoordsIdx() { return begin_idxCoords; }
|
|
int GetStartSumWordsIdx() { return begin_idxSumWords; }
|
|
int GetStartCellsIdx() { return begin_idxCells; }
|
|
int GetEndCoordsIdx() { return end_idxCoords; }
|
|
int GetEndSumWordsIdx() { return end_idxSumWords; }
|
|
int GetEndCellsIdx() { return end_idxCells; }
|
|
|
|
void SetStartCoordsIdx(int val) { begin_idxCoords = val; }
|
|
void SetStartSumWordsIdx(int val) { begin_idxSumWords = val; }
|
|
void SetStartCellsIdx(int val) { begin_idxCells = val; }
|
|
void SetEndCoordsIdx(int val) { end_idxCoords = val; }
|
|
void SetEndSumWordsIdx(int val) { end_idxSumWords = val; }
|
|
void SetEndCellsIdx(int val) { end_idxCells = val;}
|
|
|
|
const Rectangle<2> GetBoundingBox() const
|
|
{
|
|
return bbox;
|
|
}
|
|
|
|
void SetBoundingBox(const bool defined,
|
|
const double *min,
|
|
const double *max)
|
|
{
|
|
bbox.Set(true, min, max);
|
|
}
|
|
|
|
~Trip(){}
|
|
|
|
int id;
|
|
int begin_idxCoords;
|
|
int end_idxCoords;
|
|
/* Assumed that Semantics associated to num_coords
|
|
have the same index range */
|
|
int begin_idxSumWords;
|
|
int end_idxSumWords;
|
|
int begin_idxCells;
|
|
int end_idxCells;
|
|
Rectangle<2> bbox;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
4 Class SemanticTrajectory
|
|
|
|
*/
|
|
class SemanticTrajectory : public Attribute
|
|
{
|
|
|
|
public:
|
|
|
|
SemanticTrajectory(int dummy);
|
|
/*
|
|
must initialize the attribute and the DbArray
|
|
using non-standard constructor
|
|
|
|
*/
|
|
~SemanticTrajectory();
|
|
|
|
|
|
SemanticTrajectory(const SemanticTrajectory& st);
|
|
SemanticTrajectory& operator=(const SemanticTrajectory& st);
|
|
|
|
void InitializeST()
|
|
{
|
|
SetDefined(true);
|
|
}
|
|
|
|
bool EndST(const SemanticTrajectory& st)
|
|
{
|
|
if (!IsDefined())
|
|
{
|
|
Clear();
|
|
SetDefined(false);
|
|
return false;
|
|
}
|
|
coordinates.copyFrom(st.coordinates);
|
|
semantics.copyFrom(st.semantics);
|
|
semantics_Flob.copyFrom(st.semantics_Flob);
|
|
bbox = st.bbox;
|
|
return true;
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
coordinates.clean();
|
|
semantics.clean();
|
|
semantics_Flob.clean();
|
|
cells.clean();
|
|
words.clean();
|
|
words_Flob.clean();
|
|
bbox.SetDefined(false);
|
|
}
|
|
/*
|
|
Functions for Attribute type
|
|
|
|
*/
|
|
int NumOfFLOBs() const {
|
|
return 6; }
|
|
Flob *GetFLOB(const int i);
|
|
int Compare(const Attribute*) const {
|
|
return 0;}
|
|
bool Adjacent(const Attribute*) const {
|
|
return false;}
|
|
SemanticTrajectory *Clone() const;
|
|
size_t Sizeof() const {
|
|
return sizeof(*this);}
|
|
size_t HashValue() const {
|
|
return 0;}
|
|
void CopyFrom(const Attribute* right);
|
|
|
|
/* Functions for semantic datatype */
|
|
bool AddSemString(const std::string& stString);
|
|
bool GetSemString(int index, std::string& rString) const;
|
|
bool AddStringSum(const std::string& stString, int id, int count);
|
|
void AddCoordinate( const Coordinate& p);
|
|
void Destroy();
|
|
Coordinate GetCoordinate( int i ) const;
|
|
bool GetStringSum(int index, std::string& rString) const;
|
|
int GetNumCoordinates() const {
|
|
return coordinates.Size(); }
|
|
int GetNumTextData() const {
|
|
return semantics.Size(); }
|
|
const bool IsEmpty() const {
|
|
return GetNumCoordinates() == 0
|
|
&& GetNumTextData() == 0; }
|
|
const Rectangle<2> GetBoundingBox( ) const {
|
|
return bbox; }
|
|
void SetBoundingBox(const bool defined,
|
|
const double *min,
|
|
const double *max)
|
|
{
|
|
bbox.Set(true, min, max);
|
|
}
|
|
std::list<std::string> GetStringArray() const;
|
|
|
|
/* Functions for spatial summary */
|
|
void AddCell( const Cell& c);
|
|
Cell GetCell( int i ) const {
|
|
assert( 0 <= i && i < GetNumCells() );
|
|
Cell c;
|
|
cells.Get( i, &c );
|
|
return c;
|
|
}
|
|
|
|
int GetNumCells() const { return cells.Size(); }
|
|
const bool IsEmptySpatialSum() const {
|
|
return GetNumCells() == 0;}
|
|
DbArray<Cell> GetCellList() const;
|
|
|
|
|
|
static int CompareX(const void* a, const void* b)
|
|
{
|
|
const double ax = ((Cell*)a)->GetX();
|
|
const double bx = ((Cell*)b)->GetX();
|
|
if (ax < bx)
|
|
{
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
return (ax == bx) ? 0 : 1;
|
|
}
|
|
}
|
|
|
|
static int CompareY(const void* a, const void* b)
|
|
{
|
|
const double ax = ((Cell*)a)->GetY();
|
|
const double bx = ((Cell*)b)->GetY();
|
|
if (ax < bx)
|
|
{
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
return (ax == bx) ? 0 : 1;
|
|
}
|
|
}
|
|
static int CompareString(const void* a, const void* b)
|
|
{
|
|
std::string str1 = ((CcString*)a)->GetValue();
|
|
std::string str2 = ((CcString*)b)->GetValue();
|
|
int res = str1.compare(str2);
|
|
return res;
|
|
|
|
}
|
|
static bool
|
|
compare_nocase (const std::string& first,
|
|
const std::string& second)
|
|
{
|
|
unsigned int i=0;
|
|
while ( (i<first.length()) && (i<second.length()) )
|
|
{
|
|
if (first[i] < second[i]) return true;
|
|
else if (first[i]>second[i]) return false;
|
|
++i;
|
|
}
|
|
return ( first.length() < second.length() );
|
|
}
|
|
/* Functions for textual summary */
|
|
WordST GetWord( int i) const
|
|
{
|
|
assert( 0 <= i && i < GetNumWords() );
|
|
WordST w;
|
|
words.Get( i, &w );
|
|
return w;
|
|
}
|
|
int GetNumWords() const { return words.Size(); }
|
|
const bool IsEmptyTextualSum() const {
|
|
return GetNumWords() == 0;
|
|
}
|
|
static int CompareIndex(const void* a, const void* b)
|
|
{
|
|
const int32_t w1 = ((WordST*)a)->GetIdxId();
|
|
const int32_t w2 = ((WordST*)b)->GetIdxId();
|
|
if (w1 < w2)
|
|
{
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
return (w1 == w2) ? 0 : 1;
|
|
}
|
|
}
|
|
bool FindIdx(const int& key, int& pos)
|
|
{
|
|
return words.Find(&key, CompareIndex, pos);
|
|
}
|
|
bool replaceWord(WordST& w, int i)
|
|
{
|
|
return words.Put(i, w);
|
|
}
|
|
DbArray<WordST> GetTextSumList() const;
|
|
/*
|
|
OPERATOR HELPER FUNCTIONS
|
|
|
|
*/
|
|
|
|
double Similarity(SemanticTrajectory& st, double diag,
|
|
double alpha);
|
|
double Relevance(int index, std::string& str, SemanticTrajectory& st,
|
|
double diag, double alpha);
|
|
double Sim(int i, int y, std::string& str, SemanticTrajectory& st,
|
|
double diag, double alpha);
|
|
double SpatialDist(int i, int y,
|
|
SemanticTrajectory& st);
|
|
double TextualScore(std::string& str, int y,
|
|
SemanticTrajectory& st);
|
|
double GetDiagonal(Rectangle<2> &rec);
|
|
|
|
/*
|
|
OPERATOR HELPER FUNCTIONS
|
|
FOR TTSim
|
|
|
|
*/
|
|
double MinDistAux( SemanticTrajectory& st2, double wx, double wy);
|
|
double MinDistUtils(DbArray<Cell>& Ax,
|
|
DbArray<Cell>& Ay, int32_t m, double wx, double wy);
|
|
double EuclidDist(int32_t x1,
|
|
int32_t y1,
|
|
int32_t x2,
|
|
int32_t y2, double wx, double wy) const;
|
|
double BruteForce(
|
|
DbArray<Cell>& Ax,
|
|
int32_t m, double wx, double wy);
|
|
double GetCellDist(
|
|
Cell& c1, Cell& c2, double wx, double wy);
|
|
double textualScoreTT(SemanticTrajectory& st2);
|
|
|
|
|
|
/* The usual functions */
|
|
static Word In( const ListExpr typeInfo,
|
|
const ListExpr instance,
|
|
const int errorPos,
|
|
ListExpr& errorInfo,
|
|
bool& correct );
|
|
|
|
static ListExpr Out( ListExpr typeInfo, Word value );
|
|
|
|
static Word Create( const ListExpr typeInfo );
|
|
|
|
static void Delete(
|
|
const ListExpr typeInfo,
|
|
Word& w );
|
|
|
|
static void Close(
|
|
const ListExpr typeInfo,
|
|
Word& w );
|
|
|
|
static bool Save( SmiRecord& valueRecord, size_t& offset,
|
|
const ListExpr typeInfo, Word& value );
|
|
|
|
static bool Open( SmiRecord& valueRecord, size_t& offset,
|
|
const ListExpr typeInfo, Word& value );
|
|
|
|
static Word Clone( const ListExpr typeInfo,
|
|
const Word& w );
|
|
|
|
static bool KindCheck( ListExpr type,
|
|
ListExpr& errorInfo );
|
|
|
|
static int SizeOfObj();
|
|
|
|
static ListExpr Property();
|
|
|
|
static void* Cast(void* addr);
|
|
|
|
static const std::
|
|
string BasicType() { return "semantictrajectory"; }
|
|
static const bool checkType(const ListExpr type)
|
|
{
|
|
return listutils::isSymbol(type, BasicType());
|
|
}
|
|
|
|
private:
|
|
/* Constructor should never be used */
|
|
SemanticTrajectory() {}
|
|
/* DbArray to hold coordinate points */
|
|
DbArray<Coordinate> coordinates;
|
|
/* Holds position of each Text at each coordinate */
|
|
DbArray<TextData> semantics;
|
|
/* Holds all characters for one semantic trajectory */
|
|
Flob semantics_Flob;
|
|
/* DbArray to hold Cell data */
|
|
DbArray<Cell> cells;
|
|
/* DbArray to hold word data */
|
|
DbArray<WordST> words;
|
|
Flob words_Flob;
|
|
/* The bounding box that encloses the SemanticTrajectory */
|
|
Rectangle<2> bbox;
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
5 Class Batch
|
|
|
|
*/
|
|
|
|
class Batch : public Attribute
|
|
{
|
|
|
|
public:
|
|
|
|
Batch(int dummy);
|
|
~Batch();
|
|
|
|
Batch(const Batch& b);
|
|
Batch& operator=(const Batch& b);
|
|
|
|
/* Functions for Attribute type */
|
|
int NumOfFLOBs() const {
|
|
return 9; }
|
|
Flob *GetFLOB(const int i);
|
|
int Compare(const Attribute*) const {
|
|
return 0;}
|
|
bool Adjacent(const Attribute*) const {
|
|
return false;}
|
|
Batch *Clone() const;
|
|
size_t Sizeof() const {
|
|
return sizeof(*this);}
|
|
size_t HashValue() const {
|
|
return 0;}
|
|
void CopyFrom(const Attribute* right);
|
|
void Destroy();
|
|
|
|
/* The usual functions */
|
|
static Word In( const ListExpr typeInfo,
|
|
const ListExpr instance,
|
|
const int errorPos,
|
|
ListExpr& errorInfo,
|
|
bool& correct );
|
|
|
|
static ListExpr Out( ListExpr typeInfo, Word value );
|
|
static Word Create( const ListExpr typeInfo );
|
|
static void Delete(
|
|
const ListExpr typeInfo,
|
|
Word& w );
|
|
static void Close(
|
|
const ListExpr typeInfo,
|
|
Word& w );
|
|
static bool Save( SmiRecord& valueRecord, size_t& offset,
|
|
const ListExpr typeInfo, Word& value );
|
|
static bool Open( SmiRecord& valueRecord, size_t& offset,
|
|
const ListExpr typeInfo, Word& value );
|
|
static Word Clone( const ListExpr typeInfo,
|
|
const Word& w );
|
|
static bool KindCheck( ListExpr type,
|
|
ListExpr& errorInfo );
|
|
static int SizeOfObj();
|
|
static ListExpr Property();
|
|
static void* Cast(void* addr);
|
|
static const std::
|
|
string BasicType() { return "batch"; }
|
|
static const bool checkType(const ListExpr type)
|
|
{
|
|
return listutils::isSymbol(type, BasicType());
|
|
}
|
|
|
|
|
|
void Clear()
|
|
{
|
|
batchwords.clean();
|
|
batchwords_Flob.clean();
|
|
trips.clean();
|
|
bcells.clean();
|
|
bwords.clean();
|
|
bcoordinates.clean();
|
|
bsemantics.clean();
|
|
bsemantics_Flob.clean();
|
|
bwords_Flob.clean();
|
|
bcoordinates.clean();
|
|
bsemantics.clean();
|
|
bsemantics_Flob.clean();
|
|
bbox.SetDefined(false);
|
|
|
|
}
|
|
/* For Batch WordSummary */
|
|
bool GetBSumString(int index, std::string& rString) const;
|
|
bool AddBSumString(const std::string& stString,
|
|
int id, int count);
|
|
int GetWordListSize() const { return batchwords.Size(); }
|
|
|
|
const bool IsEmptyWordList() const {
|
|
return GetWordListSize() == 0;}
|
|
|
|
BatchWord GetBSumWord( int i) const {
|
|
assert( 0 <= i && i < GetWordListSize() );
|
|
BatchWord w;
|
|
batchwords.Get( i, &w );
|
|
return w;
|
|
}
|
|
|
|
/*
|
|
For Trip Information
|
|
|
|
*/
|
|
void AddTrip(const Trip& t) { trips.Append(t); }
|
|
|
|
Trip GetTrip(int i) const {
|
|
assert(0 <= i && i < GetNumTrips());
|
|
Trip t;
|
|
trips.Get(i, &t);
|
|
return t;
|
|
}
|
|
|
|
int GetNumTrips() const { return trips.Size(); }
|
|
|
|
const bool IsEmptyTripList() const {
|
|
return GetNumTrips() == 0;
|
|
}
|
|
|
|
/*
|
|
For Trip Spatial Information
|
|
|
|
*/
|
|
void AddBCell(const Cell& c) { bcells.Append(c);}
|
|
Cell GetBCell (int i) const {
|
|
assert(0 <= i && i < GetNumBCells());
|
|
Cell c;
|
|
bcells.Get(i, &c);
|
|
return c;
|
|
}
|
|
int GetNumBCells() const { return bcells.Size(); }
|
|
const bool IsEmptySpatialSum() const {
|
|
return GetNumBCells() == 0; }
|
|
|
|
/*
|
|
For Trip Word Summary information
|
|
|
|
*/
|
|
|
|
bool AddBWord(const std::string& stString,
|
|
int id, int count);
|
|
bool GetBWord(int index,
|
|
std::string& rString) const;
|
|
|
|
|
|
WordST GetBWordInfo( int i) const
|
|
{
|
|
assert( 0 <= i && i < GetNumBWords() );
|
|
WordST w;
|
|
bwords.Get( i, &w );
|
|
return w;
|
|
}
|
|
int GetNumBWords() const { return bwords.Size(); }
|
|
|
|
|
|
|
|
/* For Trip Semantics information */
|
|
bool AddBSemString(const std::string& stString);
|
|
bool GetBSemString(int index, std::string& rString) const;
|
|
|
|
/* For Trip Coordinates information */
|
|
int GetNumBCoordinates() const {
|
|
return bcoordinates.Size(); }
|
|
const bool IsEmptyBCoordinates() const {
|
|
return bcoordinates.Size() == 0; }
|
|
void AddBCoordinate(const Coordinate& c);
|
|
|
|
|
|
Coordinate GetBCoordinate( int i) const
|
|
{
|
|
assert( 0 <= i && i < GetNumBCoordinates() );
|
|
Coordinate c;
|
|
bcoordinates.Get( i, &c );
|
|
return c;
|
|
}
|
|
/* For Batch Bounding box */
|
|
const Rectangle<2> GetBoundingBox( ) const {
|
|
return bbox; }
|
|
void SetBoundingBox(const bool defined,
|
|
const double *min,
|
|
const double *max)
|
|
{
|
|
bbox.Set(true, min, max);
|
|
}
|
|
|
|
void SetBatchId(const int val)
|
|
{
|
|
batchId = val;
|
|
}
|
|
int GetBatchId()
|
|
{
|
|
return batchId;
|
|
}
|
|
|
|
|
|
/* TODO this needs to be improved */
|
|
const bool IsEmpty() const {
|
|
return GetWordListSize() == 0; }
|
|
/* TODO need to add batch word function */
|
|
|
|
/*
|
|
Helper functions for btsim
|
|
|
|
*/
|
|
double RelevanceSumBT(Rectangle<2>& mbr,
|
|
SemanticTrajectory& st,
|
|
double alpha,
|
|
double diag);
|
|
double getDistanceBT(Rectangle<2>& mbr,
|
|
double x, double y);
|
|
double EuclidDistRT(double x1,
|
|
double y1,
|
|
double x2,
|
|
double y2);
|
|
|
|
|
|
private:
|
|
/* Constructor should never be used */
|
|
Batch() {}
|
|
|
|
/* DbArray to hold word data */
|
|
DbArray<BatchWord> batchwords;
|
|
|
|
/* Flob to hold the words */
|
|
Flob batchwords_Flob;
|
|
|
|
/* DbArray to hold Trip info */
|
|
|
|
DbArray<Trip> trips;
|
|
|
|
/* DbArray to hold Trip Spatial Information */
|
|
|
|
DbArray<Cell> bcells;
|
|
|
|
/* DbArray to hold ST Trip summary */
|
|
DbArray<WordST> bwords;
|
|
|
|
/* Flob to hold actual string information for bwords */
|
|
Flob bwords_Flob;
|
|
|
|
/* DbArray to hold coordinate points */
|
|
DbArray<Coordinate> bcoordinates;
|
|
|
|
/* Holds position of each Text at each coordinate */
|
|
DbArray<TextData> bsemantics;
|
|
/* Holds all characters for one semantic trajectory */
|
|
Flob bsemantics_Flob;
|
|
|
|
/* The bounding box that encloses the batch */
|
|
Rectangle<2> bbox;
|
|
|
|
int batchId;
|
|
};
|
|
|
|
} /* end of namespace */
|
|
#endif
|