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>
#ifndef MAXDOUBLE
#ifdef _WIN32   // for MAXDOUBLE
#include <float.h>
#define MAXDOUBLE DBL_MAX
#else
#include <values.h>
#endif
#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 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.1
Committed:	Sun May 6 00:45:52 2001 UTC (23 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
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			#ifndef MAXDOUBLE
30			#ifdef _WIN32 // for MAXDOUBLE
31			#include <float.h>
32			#define MAXDOUBLE DBL_MAX
33			#else
34			#include <values.h>
35			#endif
36			#endif
37			#include "GiST.h"
38			#include "MTobject.h"
39
40			class MTentry;
41
42			// MTkey is a covering region indicated by an object and its covering radii: obj, rmin, rmax
43			// We also throw in some standard geo operators to support various query predicates, etc.
44
45			class MTkey: public GiSTobject {
46			public:
47			Object obj; // object
48			private:
49			double rmin, rmax; // covering radii
50			public:
51			friend MTentry;
52			// constructors, destructors, assignment, etc.
53			MTkey(): rmin(0), rmax(MAXDOUBLE), distance(-maxDist()), splitted(FALSE), recomp(FALSE) { }
54
55			MTkey(const MTkey& k): obj(k.obj), rmin(k.rmin), rmax(k.rmax), distance(k.distance), splitted(k.splitted), recomp(k.recomp) { }
56
57			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):
58			obj(p_obj), rmin(p_rmin), rmax(p_rmax), distance(p_distance), splitted(p_splitted), recomp(p_recomp) { }
59
60			GiSTobject Copy() const { return new MTkey(this); }
61
62			~MTkey() { }
63			GiSTobjid IsA() { return MTKEY_CLASS; }
64
65			MTkey& operator = (const MTkey& k) {
66			obj=k.obj;
67			rmin=k.rmin;
68			rmax=k.rmax;
69			distance=k.distance;
70			splitted=k.splitted;
71			recomp=k.recomp;
72			return *this;
73			}
74
75			// covering region property and comparison methods
76			int operator==(const MTkey& k) {
77			return ((!recomp)&&(!k.recomp)&&(obj==k.obj)&&(rmin==k.rmin)&&(rmax==k.rmax)&&(distance==k.distance));
78			}
79
80			int overlap (const MTkey& k) {
81			double d=obj.distance(k.obj);
82
83			return ((d+rmax>=k.rmin)&&(d+k.rmax>=rmin)&&(d<rmax+k.rmax));
84			}
85
86			int contained(const MTkey& k) {
87			double d=obj.distance(k.obj);
88
89			return ((d-rmax>=k.rmin)&&(d+rmax<=k.rmax));
90			}
91
92			int contains(const MTkey& k) {
93			double d=obj.distance(k.obj);
94
95			return ((d-k.rmax>=rmin)&&(d+k.rmax<=rmax));
96			}
97
98			double area() { return obj.area(rmax); }
99
100			// expand this covering region to contain k
101			MTkey *expand(const MTkey& k) {
102			MTkey *result;
103			double d=obj.distance(k.obj);
104
105			result=new MTkey(obj, MIN(rmin, d), MAX(rmax, d));
106			return result;
107			}
108
109			Object object() const { return obj; }
110			double minradius() const { return rmin; }
111			double maxradius() const { return rmax; }
112
113			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;
114			BOOL splitted; // indicate that the node has been splitted
115			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
116
117			// I/O methods
118			#ifdef PRINTING_OBJECTS
119			void Print(ostream& os) const {
120			os << '"';
121			os << "(" << obj << ", " << rmin << ", " << rmax << ")" << '"';
122			}
123			#endif
124			};
125
126			#ifdef PRINTING_OBJECTS
127			inline ostream& operator<< (ostream& os, const MTkey& k) {
128			k.Print(os);
129			return os;
130			}
131			#endif
132
133			class MTpenalty: public GiSTpenalty { // we have to create a sub-class in order to add the member value distance
134			public:
135			MTpenalty(): GiSTpenalty(), distance(-maxDist()) { }
136
137			MTpenalty(const double v, const double d): GiSTpenalty(v), distance(d) { }
138
139			double distance; // this is necessary since each penalty is defined by two values: the radius increase and the distance from the entry
140			};
141
142			int sizeofEntry();
143
144			class MTentry: public GiSTentry { // this are the entries stored in each node
145			public:
146			// constructors, destructors, etc.
147			MTentry() { }
148
149			MTentry(const MTkey& k, const GiSTpage p) {
150			key=new MTkey(k);
151			ptr=p;
152			}
153
154			MTentry(const MTentry& e): GiSTentry(e) {
155			key=new MTkey((MTkey )(e.key));
156			}
157
158			GiSTobjid IsA() const { return MTENTRY_CLASS; }
159
160			GiSTobject Copy() const { return new MTentry(this); }
161
162			void InitKey() { key=new MTkey; }
163
164			int IsEqual(const GiSTobject& obj) const {
165			if(obj.IsA()!=MTENTRY_CLASS) return 0;
166			return ((((MTkey )key)==(((MTkey )(((const MTentry&) obj).key)))));
167			}
168
169			// cast key member to class MTkey *. Prevents compiler warnings.
170			MTkey Key() const { return (MTkey )key; }
171
172			// basic GiST methods
173			GiSTpenalty *Penalty(const GiSTentry &newEntry) const;
174			GiSTpenalty Penalty(const GiSTentry &newEntry, MTpenalty minPenalty) const; // redefined in order to optimize distance computations
175
176			// Other methods we're required to supply
177			int CompressedLength() const {
178			return object().CompressedLength()+3sizeof(double)+2sizeof(BOOL); // compressedEntry is: Object, rmin, rmax, distance, splitted, recomp
179			}
180
181			GiSTcompressedEntry Compress() const;
182			void Decompress(const GiSTcompressedEntry entry);
183
184			// Method for ordered domains
185			int Compare(const GiSTentry& entry) const {
186			assert(entry.IsA()==MTENTRY_CLASS);
187			double d=Key()->distance-((MTentry &)entry).Key()->distance;
188			int i=0;
189
190			if(d>0) i=1;
191			else if(d<0) i=-1;
192			return i;
193			}
194
195			// I/O methods
196			#ifdef PRINTING_OBJECTS
197			void Print(ostream& os) const {
198			key->Print(os);
199			os << "->" << Ptr() << " (" << Key()->distance << ")";
200			if(Key()->splitted) os << " *";
201			if(Key()->recomp) os << " #";
202			os << endl;
203			}
204			#endif
205
206			// access to private members
207			const MTkey& cregion() const { return *Key(); }
208			Object& object() const { return Key()->obj; }
209			double minradius() const { return Key()->rmin; }
210			double maxradius() const { return Key()->rmax; }
211			void setobject(const Object& o) { Key()->obj=o; }
212			void setminradius(double d) { Key()->rmin=d; }
213			void setmaxradius(double d) { Key()->rmax=d; }
214			};
215
216			#endif