Tree-M/MT/MTentry.h

/*********************************************************************
*                                                                    *
* Copyright (c) 1997,1998, 1999                                      *
* Multimedia DB Group and DEIS - CSITE-CNR,                          *
* University of Bologna, Bologna, ITALY.                             *
*                                                                    *
* All Rights Reserved.                                               *
*                                                                    *
* Permission to use, copy, and distribute this software and its      *
* documentation for NON-COMMERCIAL purposes and without fee is       *
* hereby granted provided  that this copyright notice appears in     *
* all copies.                                                        *
*                                                                    *
* THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES ABOUT THE        *
* SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING  *
* BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY,      *
* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. THE AUTHOR  *
* SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A      *
* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS    *
* DERIVATIVES.                                                       *
*                                                                    *
*********************************************************************/

#ifndef MTENTRY_H
#define MTENTRY_H

#include <string.h>
#include <stdio.h>
#include <float.h>
#ifndef MAXDOUBLE
#define MAXDOUBLE DBL_MAX
#endif
#include "GiST.h"
#include "MTobject.h"

class MTentry;

// MTkey is a covering region indicated by an object and its covering radii: obj, rmin, rmax
// We also throw in some standard geo operators to support various query predicates, etc.

class MTkey: public GiSTobject {
public:
        Object obj;     // object
private:
        double rmin, rmax;      // covering radii
public:
friend class MTentry;
        // constructors, destructors, assignment, etc.
        MTkey(): rmin(0), rmax(MAXDOUBLE), distance(-maxDist()), splitted(FALSE), recomp(FALSE) { }

        MTkey(const MTkey& k): obj(k.obj), rmin(k.rmin), rmax(k.rmax), distance(k.distance), splitted(k.splitted), recomp(k.recomp) { }

        MTkey(Object& p_obj, const double p_rmin, const double p_rmax, const double p_distance=-maxDist(), const BOOL p_splitted=FALSE, const BOOL p_recomp=FALSE):
                obj(p_obj), rmin(p_rmin), rmax(p_rmax), distance(p_distance), splitted(p_splitted), recomp(p_recomp) { }

        GiSTobject *Copy() const { return new MTkey(*this); }

        ~MTkey() { }
        GiSTobjid IsA() { return MTKEY_CLASS; }

        MTkey& operator = (const MTkey& k) {
                obj=k.obj;
                rmin=k.rmin;
                rmax=k.rmax;
                distance=k.distance;
                splitted=k.splitted;
                recomp=k.recomp;
                return *this;
        }

        // covering region property and comparison methods
        int operator==(const MTkey& k) {
                return ((!recomp)&&(!k.recomp)&&(obj==k.obj)&&(rmin==k.rmin)&&(rmax==k.rmax)&&(distance==k.distance));
        }

        int overlap (const MTkey& k) {
                double d=obj.distance(k.obj);

                return ((d+rmax>=k.rmin)&&(d+k.rmax>=rmin)&&(d<rmax+k.rmax));
        }

        int contained(const MTkey& k) {
                double d=obj.distance(k.obj);

                return ((d-rmax>=k.rmin)&&(d+rmax<=k.rmax));
        }

        int contains(const MTkey& k) {
                double d=obj.distance(k.obj);

                return ((d-k.rmax>=rmin)&&(d+k.rmax<=rmax));
        }

        double area() { return obj.area(rmax); }

        // expand this covering region to contain k
        MTkey *expand(const MTkey& k) {
                MTkey *result;
                double d=obj.distance(k.obj);

                result=new MTkey(obj, MIN(rmin, d), MAX(rmax, d));
                return result;
        }

        Object object() const { return obj; }
        double minradius() const { return rmin; }
        double maxradius() const { return rmax; }

        double distance;        // Here we store the distance between the entry and its parent, only for index performance, in order to minimize the number of distance computations;
        BOOL splitted;  // indicate that the node has been splitted
        BOOL recomp;    // indicate that the node has been splitted but that no Union has been performed (thus radii are in a potentially inconsistent state): this can happen after a split

        // I/O methods
#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                os << '"';
                os << "(" << obj << ", " << rmin << ", " << rmax << ")" << '"';
        }
#endif
};

#ifdef PRINTING_OBJECTS
inline ostream& operator<< (ostream& os, const MTkey& k) {
        k.Print(os);
        return os;
}
#endif

class MTpenalty: public GiSTpenalty {   // we have to create a sub-class in order to add the member value distance
public:
        MTpenalty(): GiSTpenalty(), distance(-maxDist()) { }

        MTpenalty(const double v, const double d): GiSTpenalty(v), distance(d) { }
 
        double distance;        // this is necessary since each penalty is defined by two values: the radius increase and the distance from the entry
};

int sizeofEntry();

class MTentry: public GiSTentry {       // this are the entries stored in each node
public:
        // constructors, destructors, etc.
        MTentry() { }

        MTentry(const MTkey& k, const GiSTpage p) {
                key=new MTkey(k);
                ptr=p;
        }

        MTentry(const MTentry& e): GiSTentry(e) {
                key=new MTkey(*(MTkey *)(e.key));
        }

        GiSTobjid IsA() const { return MTENTRY_CLASS; }

        GiSTobject *Copy() const { return new MTentry(*this); }

        void InitKey() { key=new MTkey; }

        int IsEqual(const GiSTobject& obj) const {
                if(obj.IsA()!=MTENTRY_CLASS) return 0;
                return ((*((MTkey *)key)==(*((MTkey *)(((const MTentry&) obj).key)))));
        }

        // cast key member to class MTkey *.  Prevents compiler warnings.
        MTkey *Key() const { return (MTkey *)key; }

        // basic GiST methods
        GiSTpenalty *Penalty(const GiSTentry &newEntry) const;
        GiSTpenalty *Penalty(const GiSTentry &newEntry, MTpenalty *minPenalty) const;   // redefined in order to optimize distance computations

        // Other methods we're required to supply
        int CompressedLength() const {
                return object().CompressedLength()+3*sizeof(double)+2*sizeof(BOOL);     // compressedEntry is: Object, rmin, rmax, distance, splitted, recomp
        }

        GiSTcompressedEntry Compress() const;
        void Decompress(const GiSTcompressedEntry entry);

        // Method for ordered domains
        int Compare(const GiSTentry& entry) const {
                assert(entry.IsA()==MTENTRY_CLASS);
                double d=Key()->distance-((MTentry &)entry).Key()->distance;
                int i=0;

                if(d>0) i=1;
                else if(d<0) i=-1;
                return i;
        }

        // I/O methods
#ifdef PRINTING_OBJECTS
        void Print(ostream& os) const {
                key->Print(os);
                os << "->" << Ptr() << " (" << Key()->distance << ")";
                if(Key()->splitted) os << " *";
                if(Key()->recomp) os << " #";
                os << endl;
        }
#endif

        // access to private members
        const MTkey& cregion() const { return *Key(); }
        Object& object() const { return Key()->obj; }
        double minradius() const { return Key()->rmin; }
        double maxradius() const { return Key()->rmax; }
        void setobject(const Object& o) { Key()->obj=o; }
        void setminradius(double d) { Key()->rmin=d; }
        void setmaxradius(double d) { Key()->rmax=d; }
};

#endif
Revision:	1.3
Committed:	Fri Jul 27 12:48:23 2001 UTC (22 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.2:	+1 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	/*********************************************************************
2			* *
3			* Copyright (c) 1997,1998, 1999 *
4			* Multimedia DB Group and DEIS - CSITE-CNR, *
5			* University of Bologna, Bologna, ITALY. *
6			* *
7			* All Rights Reserved. *
8			* *
9			* Permission to use, copy, and distribute this software and its *
10			* documentation for NON-COMMERCIAL purposes and without fee is *
11			* hereby granted provided that this copyright notice appears in *
12			* all copies. *
13			* *
14			* THE AUTHORS MAKE NO REPRESENTATIONS OR WARRANTIES ABOUT THE *
15			* SUITABILITY OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING *
16			* BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, *
17			* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. THE AUTHOR *
18			* SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A *
19			* RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS *
20			* DERIVATIVES. *
21			* *
22			*********************************************************************/
23
24			#ifndef MTENTRY_H
25			#define MTENTRY_H
26
27			#include <string.h>
28			#include <stdio.h>
29	root	1.2	#include <float.h>
30	root	1.1	#ifndef MAXDOUBLE
31			#define MAXDOUBLE DBL_MAX
32			#endif
33			#include "GiST.h"
34			#include "MTobject.h"
35
36			class MTentry;
37
38			// MTkey is a covering region indicated by an object and its covering radii: obj, rmin, rmax
39			// We also throw in some standard geo operators to support various query predicates, etc.
40
41			class MTkey: public GiSTobject {
42			public:
43			Object obj; // object
44			private:
45			double rmin, rmax; // covering radii
46			public:
47	root	1.3	friend class MTentry;
48	root	1.1	// constructors, destructors, assignment, etc.
49			MTkey(): rmin(0), rmax(MAXDOUBLE), distance(-maxDist()), splitted(FALSE), recomp(FALSE) { }
50
51			MTkey(const MTkey& k): obj(k.obj), rmin(k.rmin), rmax(k.rmax), distance(k.distance), splitted(k.splitted), recomp(k.recomp) { }
52
53			MTkey(Object& p_obj, const double p_rmin, const double p_rmax, const double p_distance=-maxDist(), const BOOL p_splitted=FALSE, const BOOL p_recomp=FALSE):
54			obj(p_obj), rmin(p_rmin), rmax(p_rmax), distance(p_distance), splitted(p_splitted), recomp(p_recomp) { }
55
56			GiSTobject Copy() const { return new MTkey(this); }
57
58			~MTkey() { }
59			GiSTobjid IsA() { return MTKEY_CLASS; }
60
61			MTkey& operator = (const MTkey& k) {
62			obj=k.obj;
63			rmin=k.rmin;
64			rmax=k.rmax;
65			distance=k.distance;
66			splitted=k.splitted;
67			recomp=k.recomp;
68			return *this;
69			}
70
71			// covering region property and comparison methods
72			int operator==(const MTkey& k) {
73			return ((!recomp)&&(!k.recomp)&&(obj==k.obj)&&(rmin==k.rmin)&&(rmax==k.rmax)&&(distance==k.distance));
74			}
75
76			int overlap (const MTkey& k) {
77			double d=obj.distance(k.obj);
78
79			return ((d+rmax>=k.rmin)&&(d+k.rmax>=rmin)&&(d<rmax+k.rmax));
80			}
81
82			int contained(const MTkey& k) {
83			double d=obj.distance(k.obj);
84
85			return ((d-rmax>=k.rmin)&&(d+rmax<=k.rmax));
86			}
87
88			int contains(const MTkey& k) {
89			double d=obj.distance(k.obj);
90
91			return ((d-k.rmax>=rmin)&&(d+k.rmax<=rmax));
92			}
93
94			double area() { return obj.area(rmax); }
95
96			// expand this covering region to contain k
97			MTkey *expand(const MTkey& k) {
98			MTkey *result;
99			double d=obj.distance(k.obj);
100
101			result=new MTkey(obj, MIN(rmin, d), MAX(rmax, d));
102			return result;
103			}
104
105			Object object() const { return obj; }
106			double minradius() const { return rmin; }
107			double maxradius() const { return rmax; }
108
109			double distance; // Here we store the distance between the entry and its parent, only for index performance, in order to minimize the number of distance computations;
110			BOOL splitted; // indicate that the node has been splitted
111			BOOL recomp; // indicate that the node has been splitted but that no Union has been performed (thus radii are in a potentially inconsistent state): this can happen after a split
112
113			// I/O methods
114			#ifdef PRINTING_OBJECTS
115			void Print(ostream& os) const {
116			os << '"';
117			os << "(" << obj << ", " << rmin << ", " << rmax << ")" << '"';
118			}
119			#endif
120			};
121
122			#ifdef PRINTING_OBJECTS
123			inline ostream& operator<< (ostream& os, const MTkey& k) {
124			k.Print(os);
125			return os;
126			}
127			#endif
128
129			class MTpenalty: public GiSTpenalty { // we have to create a sub-class in order to add the member value distance
130			public:
131			MTpenalty(): GiSTpenalty(), distance(-maxDist()) { }
132
133			MTpenalty(const double v, const double d): GiSTpenalty(v), distance(d) { }
134
135			double distance; // this is necessary since each penalty is defined by two values: the radius increase and the distance from the entry
136			};
137
138			int sizeofEntry();
139
140			class MTentry: public GiSTentry { // this are the entries stored in each node
141			public:
142			// constructors, destructors, etc.
143			MTentry() { }
144
145			MTentry(const MTkey& k, const GiSTpage p) {
146			key=new MTkey(k);
147			ptr=p;
148			}
149
150			MTentry(const MTentry& e): GiSTentry(e) {
151			key=new MTkey((MTkey )(e.key));
152			}
153
154			GiSTobjid IsA() const { return MTENTRY_CLASS; }
155
156			GiSTobject Copy() const { return new MTentry(this); }
157
158			void InitKey() { key=new MTkey; }
159
160			int IsEqual(const GiSTobject& obj) const {
161			if(obj.IsA()!=MTENTRY_CLASS) return 0;
162			return ((((MTkey )key)==(((MTkey )(((const MTentry&) obj).key)))));
163			}
164
165			// cast key member to class MTkey *. Prevents compiler warnings.
166			MTkey Key() const { return (MTkey )key; }
167
168			// basic GiST methods
169			GiSTpenalty *Penalty(const GiSTentry &newEntry) const;
170			GiSTpenalty Penalty(const GiSTentry &newEntry, MTpenalty minPenalty) const; // redefined in order to optimize distance computations
171
172			// Other methods we're required to supply
173			int CompressedLength() const {
174			return object().CompressedLength()+3sizeof(double)+2sizeof(BOOL); // compressedEntry is: Object, rmin, rmax, distance, splitted, recomp
175			}
176
177			GiSTcompressedEntry Compress() const;
178			void Decompress(const GiSTcompressedEntry entry);
179
180			// Method for ordered domains
181			int Compare(const GiSTentry& entry) const {
182			assert(entry.IsA()==MTENTRY_CLASS);
183			double d=Key()->distance-((MTentry &)entry).Key()->distance;
184			int i=0;
185
186			if(d>0) i=1;
187			else if(d<0) i=-1;
188			return i;
189			}
190
191			// I/O methods
192			#ifdef PRINTING_OBJECTS
193			void Print(ostream& os) const {
194			key->Print(os);
195			os << "->" << Ptr() << " (" << Key()->distance << ")";
196			if(Key()->splitted) os << " *";
197			if(Key()->recomp) os << " #";
198			os << endl;
199			}
200			#endif
201
202			// access to private members
203			const MTkey& cregion() const { return *Key(); }
204			Object& object() const { return Key()->obj; }
205			double minradius() const { return Key()->rmin; }
206			double maxradius() const { return Key()->rmax; }
207			void setobject(const Object& o) { Key()->obj=o; }
208			void setminradius(double d) { Key()->rmin=d; }
209			void setmaxradius(double d) { Key()->rmax=d; }
210			};
211
212			#endif