def __init__(self, d, M, offset = 0, mbrs = [], pointers = []):
self.d = d
self.M = M
self.offset = offset
self.root = False
self.mbrs = [mb for mb in mbrs if mb != -2.0]
self.pointers = [p for p in pointers if p != -1]
self.elems = len(self.pointers)
self.mbr = Mbr(d)
childMbrsList = self.mbrs[:]
groupedList = listToRanges(d, len(childMbrsList), childMbrsList)
childMbrs = [Mbr(d).setRange(g) for g in groupedList]
if self.elems != len(groupedList):
raise MRtreeError("Largo del MBR debe coincidir con el de punteros")
# Se calcula el mbr del Nodo actual, en base a los mbrs de los hijos
for m in childMbrs:
self.mbr.expand(m)
# Mbrs
self.childMbrs = childMbrs
# Tuplas de (mbr, punteros) hijos
self.mbrPointers = [MbrPointer(childMbrs[i], self.pointers[i]) for i in range(self.elems)]
def setData(self, thisNodeMbr, childrenMbrPointers):
self.mbr = Mbr(self.d).setRange(thisNodeMbr.dump())
self.mbrPointers = childrenMbrPointers[:]
self.elems = 0
self.pointers = []
self.mbrs = []
self.childMbrs = []
self.mbrPointers = childrenMbrPointers[:]
for child in childrenMbrPointers:
self.elems = self.elems + 1
self.mbrs = self.mbrs + child.getMbr().dump()
self.pointers = self.pointers + [child.getPointer()]
print([str(_) for _ in seeds])
print([str(_) for _ in restMbr])
partition.partitions = [[seeds[0].getMbr(), seeds[0]], [seeds[1].getMbr(), seeds[1]]]
partition.seeds = seeds
partition.pElems = [1,1]
partitions = partition.partitionFromSeeds(restMbr, 2)
print("Partitions:")
print([str(_) for _ in partitions[0]])
print([str(_) for _ in partitions[1]])
# Nuevo MbrPointer con puntero fijo
def newMbrPointer(point):
return MbrPointer(Mbr(2).setPoint(point), 0)
if __name__ == "__main__":
parent = Mbr(2)
parent.setPoint([0.0, 1.0])
mList = [newMbrPointer([0.0, 0.6]), newMbrPointer([0.5, 0.6]), newMbrPointer([0.5, 1.0]), newMbrPointer([0.5, 0.3]), newMbrPointer([1.0, 0.6]), newMbrPointer([0.7, 0.0])]
print([str(_) for _ in mList])
parent.setRange([0.0, 1.0, 0.0, 1.0])
print("Linear")
testPartition(LinealPartition(), parent, mList)
print([ str(_) for e in LinealPartition().partition(parent, mList, 2) for _ in e])
print("Cuadratico")
testPartition(CuadraticPartition(), parent, mList)
print([ str(_) for e in CuadraticPartition().partition(parent, mList, 2) for _ in e])
print("Sweep")
sp = SweepPartition()
class MRtree(object):
def __init__(self, d, M, offset = 0, mbrs = [], pointers = []):
self.d = d
self.M = M
self.offset = offset
self.root = False
self.mbrs = [mb for mb in mbrs if mb != -2.0]
self.pointers = [p for p in pointers if p != -1]
self.elems = len(self.pointers)
self.mbr = Mbr(d)
childMbrsList = self.mbrs[:]
groupedList = listToRanges(d, len(childMbrsList), childMbrsList)
childMbrs = [Mbr(d).setRange(g) for g in groupedList]
if self.elems != len(groupedList):
raise MRtreeError("Largo del MBR debe coincidir con el de punteros")
# Se calcula el mbr del Nodo actual, en base a los mbrs de los hijos
for m in childMbrs:
self.mbr.expand(m)
# Mbrs
self.childMbrs = childMbrs
# Tuplas de (mbr, punteros) hijos
self.mbrPointers = [MbrPointer(childMbrs[i], self.pointers[i]) for i in range(self.elems)]
def __str__(self):
return "Tree: p=" + str(self.offset) + " " + str(self.mbr) + "\nchilds=" + str([str(_) for _ in self.mbrPointers])
def toStr(self):
return "p=" + str(self.offset) + " " + str(self.mbr) + " N° childs=" + str(len(self.mbrPointers))
# Setea la info provenient de un split dentro del nodo u hoja
def setData(self, thisNodeMbr, childrenMbrPointers):
self.mbr = Mbr(self.d).setRange(thisNodeMbr.dump())
self.mbrPointers = childrenMbrPointers[:]
self.elems = 0
self.pointers = []
self.mbrs = []
self.childMbrs = []
self.mbrPointers = childrenMbrPointers[:]
for child in childrenMbrPointers:
self.elems = self.elems + 1
self.mbrs = self.mbrs + child.getMbr().dump()
self.pointers = self.pointers + [child.getPointer()]
# Setea la info proveniente de un split by cut
def setDataChildren(self, childrenMbrPointers):
self.mbrPointers = childrenMbrPointers[:]
self.elems = 0
self.pointers = []
self.mbrs = []
self.childMbrs = []
self.mbrPointers = childrenMbrPointers[:]
for child in childrenMbrPointers:
self.elems = self.elems + 1
self.mbrs = self.mbrs + child.getMbr().dump()
self.pointers = self.pointers + [child.getPointer()]
# Añade un hijo al arbol actual (Una tupla (mbr, pointer))
def insert(self, mbrPointer):
pointer = mbrPointer.getPointer()
mbr = mbrPointer.getMbr()
self.pointers = self.pointers + [pointer]
self.elems = self.elems + 1
self.mbr.expand(mbr)
self.mbrs = self.mbrs + mbr.dump()
self.mbrPointers = self.mbrPointers + [MbrPointer(mbr, pointer)]
# Actualiza un hijo en base a puntero, y, actualiza el mbr del arbol
def updateChild(self, mbrPointer):
change = False
for i in range(self.elems):
m = self.mbrPointers[i]
if m.getPointer() == mbrPointer.getPointer():
self.mbrPointers[i] = mbrPointer
change = True
break
if not change:
raise MRtreeError("Error actualizando hijo, no encontrado")
self.mbr.expand(mbrPointer.getMbr())
def cutOnDimension(self, dim, cut):
mbrs = self.mbr.cutOnDimension(dim, cut)
newChildren = []
newChildren2 = []
newMbr = mbrs[0]
newMbr2 = mbrs[1]
for mb in self.mbrPointers:
if mb.getMbr().areIntersecting(newMbr):
newChildren = newChildren + [mb]
else:
newChildren2 = newChildren2 + [mb]
self.setData(newMbr, newChildren)
newNode = MNode(self.M, self.d, -1, [], [])
newNode.setData(newMbr2, newChildren2)
return newNode
def getPointer(self):
return self.offset
def setPointer(self, p):
self.offset = p
# Esta estructura se ocupa para algoritmos del Rtree
def getChildren(self):
return self.mbrPointers
def getChildrenMbrs(self):
return self.childMbrs
def getMbr(self):
return self.mbr
# Esta estructura se ocupa para insertar una version compacta del Nodo a otro Nodo u Hoja
def getMbrPointer(self):
return MbrPointer(self.mbr, self.offset)
def dumpMbrs(self):
return self.mbrs + [-2.0 for _ in range((self.M - self.elems )*2*self.d)]
def dumpPointers(self):
return self.pointers + [-1 for _ in range(self.M - self.elems)]
def setAsRoot(self, rootOffset = 0):
self.root = True
self.offset = rootOffset
def unsetRoot(self):
self.root = False
def needToSplit(self):
return self.elems == self.M
def isANode(self):
pass
def isALeaf(self):
pass
