<Nitpicky> Saddle points are still there in the underlying height map, the ambiguity disappears only for the height interpolation over the triangle.</Nitpicky> Looking forward to the code!
class Coordinate():
def __init__(self, x = None, y = None, z = None, radius = None, index = None, distance = None):
self.x = x
self.y = y
self.z = z
self.xyz = (x, y, z)
self.radius = radius
self.index = index
self.distance = distanceclass HeightMap():
def __init__(self, flat, columns, rows, zmin, zmax, array, mapSize):
self.flat = flat
self.columns = columns
self.rows = rows
self.zmin = zmin
self.zmax = zmax
self.array = array
self.mapSize = mapSize
def fraction_to_meters(self, fraction):
m_value = fraction * (self.zmax-self.zmin) + self.zmin
return m_value
def coord_to_fraction(self, x, y, output='f'):
x+=self.mapSize/2
y+=self.mapSize/2
x_interval = self.mapSize / (self.columns-1)
y_interval = self.mapSize / (self.rows-1)
column = int(x//x_interval)
row = int(y//y_interval)
x1 = column*x_interval
x2 = (column+1)*x_interval
y1 = row*y_interval
y2 = (row+1)*y_interval
x_factor = (x-x1)/x_interval
y_factor = (y-y1)/y_interval
total_area = x_interval*y_interval
a_area = x_interval*(1-x_factor)*y_interval*(1-y_factor)
b_area = x_interval*x_factor*y_interval*(1-y_factor)
c_area = x_interval*(1-x_factor)*y_interval*y_factor
d_area = x_interval*x_factor*y_interval*y_factor
a_weight = a_area/total_area
b_weight = b_area/total_area
c_weight = c_area/total_area
d_weight = d_area/total_area
az = self.array[row][column]
bz = self.array[row][column+1]
cz = self.array[row+1][column]
dz = self.array[row+1][column+1]
z = az*a_weight+bz*b_weight+cz*c_weight+dz*d_weight
if output == 'm':
z = self.fraction_to_meters(z)
return zclass TriCell():
def __init__(self):
self.a = None
self.b = None
self.c = None
self.value = 0
def evaluate(self, elevation):
a = (self.a.z > elevation)*4
b = (self.b.z > elevation)*2
c = (self.c.z > elevation)*1
self.value = sum([a, b, c])
def interpolate(self, p0, p1, z):
dx = p1.x-p0.x
dy = p1.y-p0.y
dz = p1.z-p0.z
rel_z = z-p0.z
if dz == 0:
fraction = 0
else:
fraction = rel_z/dz
x = p0.x+dx*fraction
y = p0.y+dy*fraction
return Coordinate(x, y, z)
def line_coords(self, elevation):
lines = []
if self.value in (0, 7):
return lines
alfa = self.interpolate(self.a, self.b, elevation)
beta = self.interpolate(self.b, self.c, elevation)
gamma = self.interpolate(self.c, self.a, elevation)
if self.value in (1,6):
lines.append((beta, gamma))
elif self.value in (2,5):
lines.append((alfa, beta))
elif self.value in (3,4):
lines.append((alfa, gamma))def contours(heightMap, size=100, _range=[-500,-500,500,500], step=None):
'''For marching squares'''
def make_cell():
'''Generates a single cell'''
ax = dx = columnStart+columnSize*column
ay = by = rowStart+rowSize*row
bx = cx = ax+columnSize
cy = dy = ay+rowSize
cell = Cell()
cell.a = Coordinate(ax, ay)
cell.b = Coordinate(bx, by)
cell.c = Coordinate(cx, cy)
cell.d = Coordinate(dx, dy)
for corner in (cell.a, cell.b, cell.c, cell.d):
get_corner_z(corner)
cells.append(cell)
def make_triangle_cell():
'''Generates two triangle cells'''
x0 = columnStart+columnSize*column
y0 = rowStart+rowSize*row
x1 = x0+columnSize
y1 = y0+rowSize
if row%2 == 0:
ax = bx = x0
cx = dx = x1
bx += columnSize*0.5
cx += columnSize*0.5
ay = dy = y1
by = cy = y0
else:
ax = dx = x0
bx = cx = x1
cx += columnSize*0.5
dx += columnSize*0.5
ay = by = y0
cy = dy = y1
a = Coordinate(ax, ay)
b = Coordinate(bx, by)
c = Coordinate(cx, cy)
d = Coordinate(dx, dy)
for corner in (a, b, d):
get_corner_z(corner)
cell1 = TriCell()
cell1.a = a
cell1.b = b
cell1.c = d
cells.append(cell1)
if cx <= hm.mapSize/2:
get_corner_z(c)
cell2 = TriCell()
cell2.a = b
cell2.b = c
cell2.c = d
cells.append(cell2)
def get_corner_z(corner):
'''Gets the z value for a cell corner'''
global zmax, zmin
corner.z = hm.coord_to_fraction(corner.x, corner.y, 'm')
if zmax is None or corner.z > zmax:
zmax = corner.z
if zmin is None or corner.z < zmin:
zmin = corner.z
#print(column, row, corner.x, corner.y, corner.z, sep='\t')
def print_cell_values():
for row in range(divRow):
this_row = []
for column in range(divColumn):
cellindex = row*divColumn+column
cell = cells[cellindex]
this_row.append(cell.value)
print(*this_row, sep='\t')
print('\n')
# 1. Calculate cell size
hm = heightMap
if _range == None:
r = hm.mapSize/2
_range = [-r, -r, r, r]
else:
for i in range(4):
if _range[i] < -hm.mapSize/2:
_range[i] = -hm.mapSize/2
elif _range[i] > hm.mapSize/2:
_range[i] = hm.mapSize/2
rowStart = int(_range[1])
rowEnd = int(_range[3])
rowLen = rowEnd - rowStart
columnStart = int(_range[0])
columnEnd = int(_range[2])
columnLen = columnEnd - columnStart
divRow = rowLen//size
divColumn = columnLen//size
rowSize = rowLen/divRow
columnSize = columnLen/divColumn
# 2. Sample the heightmap
cells = []
global zmax, zmin
zmin = None
zmax = None
for row in range(divRow):
for column in range(divColumn):
make_triangle_cell()
#make_cell()
#print(zmin, zmax)
# 3. subdivide range zmin, zmax to determine which lines to draw
if step == None:
lines, step, factor = subdivide(zmin, zmax, 10)
else:
lines, step, factor = subdivide(zmin, zmax, step=step)
#print(*lines, sep='\t')
# 4. Evaluate cells and get line coordinates
lineDict = {}
for elevation in lines:
lineDict[elevation] = []
for cell in cells:
cell.evaluate(elevation)
lineDict[elevation] += cell.line_coords(elevation)
return lineDict, zmin, zmaxdef subdivide(p0, p1, subdivisions=3, step=None, _range=None):
'''Subdivides the distance p1-p0'''
def stepFinder(n, subdivisions):
'''Finds the step size'''
#Find if n is negative
sign = 1 - (n < 0)*2
#List containing the available step factors
factors = (1, 2, 2.5, 5)
#Extract significand and potencia
string = '%.1E' %(n/subdivisions)
[significand, potencia] = [float(s) for s in string.split('E')]
#Select step factor and return step size
stepFactor = min(factors, key=lambda x:abs(x-abs(significand)))*sign
step = stepFactor*10**potencia
return step, stepFactor
p0, p1 = sorted((p0, p1))
n = p1-p0
factor = None
if step==None:
step, factor = stepFinder(n, subdivisions)
if _range==None:
_range=(p0, p1)
r0, r1 = _range[0], _range[1]
offset = (r0//step)*step
my_list = []
i = 1
while float(format(offset+i*step, 'g')) < r1:
my_list.append(float(format(offset+i*step, 'g')))
i += 1
return my_list, step, factor
Probably be over 2TB download in less than a week.
for elevation in lineDict:
coordinates = lineDict[elevation]
lines = [[a, b] for a, b in coordinates]
for i in range(len(lines)):
line = lines.pop(0)
start = line[0]
end = line[-1]
for other_line in lines:
other_start = other_line[0]
other_end = other_line[-1]
if (start.x, start.y) == (other_start.x, other_start.y):
other_line.reverse()
other_line += line[1:]
break
elif (start.x, start.y) == (other_end.x, other_end.y):
other_line += line[1:]
break
elif (end.x, end.y) == (other_start.x, other_start.y):
other_line.reverse()
line.reverse()
other_line += line[1:]
break
elif (end.x, end.y) == (other_end.x, other_end.y):
line.reverse()
other_line += line[1:]
break
else:
lines.append(line)
lineDict[elevation] = lines
What you have in mind, a driving game like AC or a shooting game?
Panel lottery, not worth the hassle if reasonable already.
Finally bought additional storage for my growing photo collection - two 3TB drives on the cheap that I've setup in RAID I. Gives me an extra TB over my previous setup and redundancy that is desperately needed when working with 10+ years of digital photos.
That being said, I do need to upgrade from my epic Phenom X3 someday
