def bresenham(Ipoint, point1, fPoint, xSize, ySize, prim, exception):
reload (GeoMath)
reload (DetermineVectors)
reload (Validator)
curPoint = point1
dirVec = GeoMath.vecNormalize(GeoMath.vecSub(fPoint, Ipoint))
# Get the horizontal and vertical vectors
xVec, yVec = DetermineVectors.DetermineVectors.detVec(prim, dirVec, exception)
xSizeVec = GeoMath.vecScalarProduct(xVec, xSize)
ySizeVec = GeoMath.vecScalarProduct(yVec, ySize)
vecToFinal = GeoMath.vecSub(curPoint, fPoint)
sizeToFinalx = abs(GeoMath.vecDotProduct(vecToFinal, xVec) / GeoMath.vecModul(xVec))
sizeToFinaly = abs(GeoMath.vecDotProduct(vecToFinal, yVec) / GeoMath.vecModul(yVec))
if(sizeToFinalx > xSize or sizeToFinaly > ySize):
pointx = GeoMath.vecPlus(curPoint, xSizeVec)
pointy = GeoMath.vecPlus(curPoint, ySizeVec)
pointxy = GeoMath.vecPlus(curPoint, xSizeVec)
pointxy = GeoMath.vecPlus(pointxy, ySizeVec)
curxVec = GeoMath.vecNormalize(GeoMath.vecSub(pointx, Ipoint))
curyVec = GeoMath.vecNormalize(GeoMath.vecSub(pointy, Ipoint))
curxyVec = GeoMath.vecNormalize(GeoMath.vecSub(pointxy, Ipoint))
# We get the max dot product, the vector nearest to line
dotx = GeoMath.vecDotProduct(curxVec, dirVec)
doty = GeoMath.vecDotProduct(curyVec, dirVec)
dotxy = GeoMath.vecDotProduct(curxyVec, dirVec)
pointsTemp = {}
if(Validator.Validator.pointInsidePrim(pointx, prim)): pointsTemp[dotx] = pointx
if(Validator.Validator.pointInsidePrim(pointy, prim)): pointsTemp[doty] = pointy
if(Validator.Validator.pointInsidePrim(pointxy, prim)): pointsTemp[dotxy] = pointxy
if(not pointsTemp):
point = list(fPoint)
else:
bestPoint = list(pointsTemp[sorted(pointsTemp)[len(pointsTemp) - 1]])
point = bestPoint
else:
point = list(fPoint)
'''
if(prim.number()==54):
print "Ipoint, fpoint"
print Ipoint, fPoint
print "pointx, pointy, pointxy"
print pointx, pointy, pointxy
print "Dots"
print dotx, doty, dotxy
print "sizes"
print sizeToFinalx, sizeToFinaly
print "Point"
print point
'''
return point
def getRandomPattern(self,
wavelength,
pointI,
pointF,
normal,
height=None):
logging.debug("Class Data, method getRandomPattern")
add_noise = Add_noise()
# Calculate height if not get
if (not height):
height = self.sizey / 2
transformed_points = add_noise.apply_noise([pointI, pointF],
normal,
height,
True,
frequency='medium')
# Now we add the heigth for each point, because the noise lies between [-sizey/2, sizey/2]
# and we want [0, sizey]
# So we get the direction of the noise and multiply by the heigth/2 and plus to the points
positive_points = []
# Calculate the sum to each point
normal_with_module = GeoMath.vecScalarProduct(normal, height / 2)
for point in transformed_points:
positive_points.append(GeoMath.vecPlus(point, normal_with_module))
logging.debug("Generated pattern finish: " + str(positive_points))
dirWithModule = GeoMath.vecSub(pointF, pointI)
# normal points size wavelenght
pattern = GlassPatternDynamic(normal, positive_points,
[dirWithModule[0], dirWithModule[1]],
wavelength)
return pattern
def applyJoker(self, point1, point2, vecH, vecV):
vec = GeoMath.vecSub(point2, point1)
dotH = GeoMath.vecDotProduct(vec, vecH) / GeoMath.vecModul(vecH)
dotV = GeoMath.vecDotProduct(vec, vecV) / GeoMath.vecModul(vecV)
if (math.fabs(dotH) < math.fabs(dotV)):
normal = GeoMath.vecNormalize(vecH)
else:
normal = GeoMath.vecNormalize(vecV)
norV = GeoMath.vecNormalize(vecV)
norH = GeoMath.vecNormalize(vecH)
sizeX = GeoMath.vecModul(GeoMath.vecScalarProduct(norH, dotH))
sizeY = GeoMath.vecModul(GeoMath.vecScalarProduct(norV, dotV))
pointI1 = GeoMath.vecPlus(point1,
GeoMath.vecScalarProduct(norH, dotH / 2))
pointI2 = GeoMath.vecPlus(pointI1,
GeoMath.vecScalarProduct(norV, dotV))
return WallPattern(normal,
[list(point1), pointI1, pointI2,
list(point2)], [sizeX, sizeY], 0)
def do(self, scale=False):
# Calcule points to tbn matrix
self.calculatePoints()
# Get some arbitrary vectors conected from vertices of prim
vec1 = GeoMath.vecSub(self.get_previous_point(), self.get_point_which_is_relative())
vec2 = GeoMath.vecSub(self.get_next_point(), self.get_point_which_is_relative())
# logging.debug('Two arbitrary vec1 and vec2:' + str(vec1) + ' ' + str(vec2))
# We have to know which angle reside between the two coencted vectors, to know if suposed vectors
# in tangent space will be correct
angle = GeoMath.vecDotProduct(vec1, vec2) / (GeoMath.vecModul(vec1) * GeoMath.vecModul(vec2))
angle = math.acos(angle)
angle = math.degrees(angle)
# logging.debug('Angle between vecs:' + str(angle))
# We put relative one arbitrary point to tangent space
# logging.debug('Point relative:' + str(self.get_point_which_is_relative()))
# Determine x and y vectors, now we'll have suposed horizontal and vertical vectors acording to
# prim and direction of the crack
hasTheNormalToY = GeoMath.vecDotProduct(list(self.get_prim().normal()), [0, 1, 0])
# logging.debug('Has the normal to y?:' + str(hasTheNormalToY))
if(hasTheNormalToY < (1 - epsilon) and hasTheNormalToY > (-1 + epsilon)):
vecH, vecV = DetermineVectors.DetermineVectors.detVec(self.get_prim(), [0, 1, 0], [0, 0, 1])
# logging.debug('Yes, it has the normal to y and vecs are:' + str(vecH) + ' ' + str(vecV))
else:
vecH, vecV = DetermineVectors.DetermineVectors.detVec(self.get_prim(), [0, 0, 1], [0, 0, 1])
# logging.debug('No, it isnt has the normal to y and vecs are:' + str(vecH) + ' ' + str(vecV))
# CHAPUZA CON NUMEROS COMPLEJOS!!! Precision de python pésima, 1.000000001>1?? no! y math.acos error
cosAngle = GeoMath.vecDotProduct(vecH, vec1) / (GeoMath.vecModul(vec1) * GeoMath.vecModul(vecH))
complexAngle = cmath.acos(cosAngle)
if(complexAngle.imag == 0):
angleBetweenDetVecAndVecH = math.acos(cosAngle)
else:
if(cosAngle < 0):
angleBetweenDetVecAndVecH = math.acos(-1)
else:
angleBetweenDetVecAndVecH = math.acos(1)
# Now we have to ensure that the vec1 has the same direction that the horizontal vector, if not, we
# change and the horizontal vector will be vec2. Also we have to check if the prim is not a quad,
# in this case we have to get the vertical vector from horizontal vector, rotating the known angle
# between the two vectors conected in prim (in quad we know that the angle is 90 and we already have the
# good vectors)
if((math.fabs(angleBetweenDetVecAndVecH) < epsilon) or (math.fabs(angleBetweenDetVecAndVecH) > (math.pi - epsilon))):
if(scale):
x = GeoMath.vecScalarProduct([1, 0, 0], GeoMath.vecModul(vec1))
x = [1, 0, 0]
y = GeoMath.rotateVecByVec(x, [0, 0, 1], angle)
if(scale):
y = GeoMath.vecScalarProduct(GeoMath.vecNormalize(y), GeoMath.vecModul(vec2))
tbn = GeoMath.createTBNmatrix(self.get_previous_point(), self.get_point_which_is_relative(), self.get_next_point(), x, [0, 0], y)
else:
if(scale):
x = [1, 0, 0]
y = GeoMath.rotateVecByVec(x, [0, 0, 1], angle)
if(scale):
y = GeoMath.vecScalarProduct(GeoMath.vecNormalize(y), GeoMath.vecModul(vec1))
tbn = GeoMath.createTBNmatrix(self.get_previous_point(), self.get_point_which_is_relative(), self.get_next_point(), y, [0, 0], x)
# logging.debug('tbn: ' + str(tbn.printAttributes()))
tbnInverse = GeoMath.Matrix(3, 3)
tbnInverse.copy(tbn)
tbnInverse.matrix3Inverse()
self.set_tbn(tbn)
self.set_tbn_inverse(tbnInverse)
def calculate_floors_position(self):
logging.debug(
'START Class FloorStructure, method calculate_floors_position')
points_base_node = [
list(p.position())
for p in self.get_base_node().geometry().points()
]
lowest_point = list(
self.get_base_node().geometry().boundingBox().minvec())
# Now we stract the points of the floor from the building
structure_of_floor = []
for point in points_base_node:
# If the point has the same y position than the lowest point, the
# point will be a floor point
# We cant do that beacuse the points returned from geometry of houdini
# node are ordered, and the points can be the structure of the floor
# just as it is
if (point[1] == lowest_point[1]):
# Mapping to y=0
structure_of_floor.append(list(point))
logging.debug("Structure of floor " + str(structure_of_floor))
#======================================================================
# Now we want to found the lowest virtual plant with a crack primitive
# touching it. Also we want the previous of this floor, because this
# floor will be visible trough the hole of the next floor
#======================================================================
# Initialize position of the first virtual floor in the center point of the base
virtual_floor = floor.Floor(self.get_floor_params(),
structure_of_floor)
previous_virtual_floor = virtual_floor
connected_prims_with_crack = virtual_floor.intersections_with_crack(
self.get_crack().patternCrack, self.get_path())
floor_inside = virtual_floor.inside(self.get_base_node())
# MAYFIX: structure points are the same for each floor, we assume that
# the building have the same boundary for each floor
increment = GeoMath.vecScalarProduct(
[0, 1, 0],
self.extract_parm_from_user_restrictions(
'floor_default_put_each_y'))
logging.debug("Increment " + str(increment))
acumulated_increment = [0, 0, 0]
while (not connected_prims_with_crack and floor_inside):
logging.debug("Acumulated increment " + str(acumulated_increment))
acumulated_increment = GeoMath.vecPlus(acumulated_increment,
increment)
new_structure_of_floor = [
GeoMath.vecPlus(position, acumulated_increment)
for position in structure_of_floor
]
previous_virtual_floor = virtual_floor
virtual_floor = floor.Floor(self.get_floor_params(),
new_structure_of_floor)
connected_prims_with_crack = (
virtual_floor.intersections_with_crack(
self.get_crack().patternCrack, self.get_path()))
floor_inside = virtual_floor.inside(self.get_base_node())
# If not inside, delete it
if (not floor_inside):
logging.debug("Floor_outside")
virtual_floor = None
#=======================================================================
# #=======================================================================
# # once we found the first virtual floor, we check if is it the same
# # than the previous virtual floor. If it is the same will assign the
# # next virtual floor possible. Then we check if this floor is outside
# # the building. If the virtual floor reside outside building we delete it
# # and not continue working with floors
# #=======================================================================
# if(previous_virtual_floor == virtual_floor):
# #Check if it is inside building
# floor_inside = virtual_floor.inside(points_base_node)
# #If not inside, delete it
# if(not floor_inside):
# virtual_floor = None
#=======================================================================
# The first floor is untouched
destroyed_virtual_floors = [previous_virtual_floor]
#=======================================================================
# Now we have to create the other floors until we reached the first floor
# outside building or not connected with crack prims
#=======================================================================
if (virtual_floor):
connected_prims_with_crack = True
floor_inside_building = True
while (connected_prims_with_crack and floor_inside_building):
destroyed_virtual_floors.append(virtual_floor)
logging.debug("Acumulated increment " +
str(acumulated_increment))
acumulated_increment = GeoMath.vecPlus(acumulated_increment,
increment)
new_structure_of_floor = [
GeoMath.vecPlus(position, acumulated_increment)
for position in structure_of_floor
]
previous_virtual_floor = virtual_floor
virtual_floor = floor.Floor(self.get_floor_params(),
new_structure_of_floor)
connected_prims_with_crack = (
virtual_floor.intersections_with_crack(
self.get_crack().patternCrack, self.get_path()))
floor_inside = virtual_floor.inside(self.get_base_node())
# Now add the last floor if needed
if (virtual_floor.inside(self.get_base_node())):
destroyed_virtual_floors.append(virtual_floor)
else:
# Only one floor
destroyed_virtual_floors.append(previous_virtual_floor)
# Display floors in houdini as a cubes
#createfloors.CreateFloors(destroyed_virtual_floors, self.get_geo())
self.floors = destroyed_virtual_floors
logging.debug(
'END Class FloorStructure, method calculate_floors_position')
