def __init__ (self, w=1024*20, h=1024*20):
self.w = w
self.h = h
self.Q_views = quadtree.quadtree()
self.Q_back = quadtree.quadtree()
self.Q_obs = quadtree.quadtree()
self.generate_random_field()
def __init__(self, w=1024 * 20, h=1024 * 20):
self.w = w
self.h = h
self.Q_views = quadtree.quadtree()
self.Q_back = quadtree.quadtree()
self.Q_obs = quadtree.quadtree()
self.generate_random_field()
def main():
xp = [(0.2, 0.2, 0.3), (0.4, 0.1, 0.2)]
yp = [(0.2, 0.3, 0.3), (0.9, 0.3, 0.9), (0.2, 0.4, 0.4)]
ps = xp + yp
dimensions = 3
bbox = [[0, 0, 0], [1, 1, 1]] # You can randomly translate bbox
depth = 8
vs = []
us = []
cost = []
coordinate_map = {}
ind = [0]
quadtree(ps, dimensions, bbox, depth, vs, us, cost, coordinate_map, ind)
xs = [0.0 for i in range(ind[0])]
for x, y, z in xp:
xs[coordinate_map[(x, y, z)]] += 1
ys = [0.0 for i in range(ind[0])]
for x, y, z in yp:
ys[coordinate_map[(x, y, z)]] += 1
creation = [0.2] * ind[0]
deletion = [0.3] * ind[0]
print(treegkr(vs, us, cost, creation, deletion, xs, ys))
#! /usr/bin/env python
import numpy as np
import quadtree
data = np.fromfile('test_model',dtype=np.float32).reshape(1024,1024)
temp_level,temp_center_x,temp_center_y,data_big = quadtree.quadtree(data,0.2,8)
quadtree.plot_QDT(temp_level,temp_center_x,temp_center_y,data_big)
#! /usr/bin/env python
import numpy as np
import quadtree
data = np.fromfile('test_model', dtype=np.float32).reshape(1024, 1024)
temp_level, temp_center_x, temp_center_y, data_big = quadtree.quadtree(
data, 0.2, 8)
quadtree.plot_QDT(temp_level, temp_center_x, temp_center_y, data_big)
def makeRaster(partNum, sides, pAxis, sAxis, cog, fullRender, num, outputName, wid):
#vision axis is perpendicular to both basis vectors
vAxis = np.cross(pAxis, sAxis)
#origin at some distance along vAxis from cog of object, f = further distance to camera
#w, h must be integers (dimensions of output image)
#w, h, unitsperpixel should be 1 / a power of 2 (for quadtree); w * unitsperpixel = 256
originD, f, w, h, unitsPerPixel = -100, -40, wid, wid, 256.0/wid
origin = cog + originD * vAxis
camera = origin + f * vAxis
im = Image.new("RGB", (w, h), "white")
mInv = np.linalg.inv(np.array([pAxis, sAxis, vAxis]).T)
#Each side consists of three triplets specifying the vertexes of a triangle in R3
#sides = centeredMesh.points
#Convert sides to faces in camera reference frame
faces = []
minZ, maxZ = 100000, -1
for s in sides:
face = []
for i in range(3):
points = np.array(s[i * 3: i * 3 + 3])
transformed = np.dot(mInv, points - origin)
vertex = [transformed[i] for i in range(3)]
z = transformed[2]
if (z < minZ):
minZ = z
if (z > maxZ):
maxZ = z
face.append(vertex)
faces.append(face)
#puts z from part into range 0 to 255
def fitZ(z):
return (z - minZ)/(maxZ - minZ) * 255
#create quadtree with dim = width of screen in units, min width = width of pixel in units
qtree = quadtree(w * unitsPerPixel, unitsPerPixel)
#add faces to quadtree
for f in faces:
qtree.addTriangle(f)
for xp in range(int(-w/2), int(w/2)):
for yp in range(int(-h/2), int(h/2)):
#each pixel corresponds to some number of units
x, y = xp * unitsPerPixel, yp * unitsPerPixel
#find all triangles in quadtree node that x is in
closeTriangles = qtree.getTrianglesOfPoint([x, y])
validTriangles = []
for tri in closeTriangles:
if isInside(tri, (x, y)):
validTriangles.append(tri)
#default white if no triangles contained point
col = (255, 255, 255)
if (len(validTriangles) != 0):
if (not fullRender):
col = (255, 0, 0)
else:
#if there are multiple valid triangles, choose smallest average z
minTri = None
for tri in validTriangles:
if (minTri == None or avgD(minTri, 2) > avgD(tri, 2)):
minTri = tri
#maps to range 55 to 200
zVal = fitZ(getZ(minTri, (x, y)))
#improve by making dist = dist to camera, not just z value
c = int(max(min(255, 255 - zVal), 0))
col = (c, 0, 0)
im.putpixel((xp + int(w/2), yp + int(h/2)), col)
def makeBinary(img, n):
img = img.resize((128, 128))
back = Image.new("RGB", (420, 420), "white")
st = int((420 - 128)/2)
back.paste(img, (st, st))
back.save(str(outputName) + "-" + str(n + 1) + ".png")
if (fullRender):
im.save(str(outputName) + "-" + str(num) + ".png")
#create binary version if not already created
bim = Image.new("RGB", (w, h), "white")
for xp in range(w):
for yp in range(h):
oldC = im.getpixel((xp, yp))
if (oldC == (255, 255, 255)):
bim.putpixel((xp, yp), oldC)
else:
bim.putpixel((xp, yp), (255, 0, 0))
makeBinary(bim, num)
else:
makeBinary(im, num)
if __name__ == '__main__':
dataset = initialize()
xsize = dataset.RasterXSize
ysize = dataset.RasterYSize
print 'Size: ', xsize, '/', ysize
print 'Driver: ', dataset.GetDriver().ShortName
datagrid = readImage(dataset,xsize,ysize)
saveGrid(datagrid)
datagrid = reclassify(datagrid)
createImage(dataset, datagrid, 'testimg1.img')
xxx = quadtree.quadtree()
dataset = None
"""
dataset = gdal.Open(filename, GA_ReadOnly)
if dataset is None:
print("error opening file")
print 'Driver: ', dataset.GetDriver().ShortName,'/', \
dataset.GetDriver().LongName
print 'Size is ',dataset.RasterXSize,'x',dataset.RasterYSize, \
'x',dataset.RasterCount
print 'Projection is ',dataset.GetProjection()
geotransform = dataset.GetGeoTransform()
if not geotransform is None:
print 'Origin = (',geotransform[0], ',',geotransform[3],')'
