def fromOriginAndSize(cls, origin, width, length, height, convertToMeters=1,
                          nDivXYZ=None, grading=None, xAxis=None):
        """Create BlockMeshDict from BFBlockGeometries.

        Args:
            origin: Minimum point of bounding box as (x, y, z).
            width: Width in x direction.
            length: Length in y direction.
            height: Height in y direction.
            convertToMeters: Scaling factor for the vertex coordinates.
            nDivXYZ: Number of divisions in (x, y, z) as a tuple (default: 5, 5, 5).
            grading: A simpleGrading (default: simpleGrading(1, 1, 1)).
            xAxis: An optional tuple that indicates the xAxis direction
                (default: (1, 0)).
        """
        _xAxis = vectormath.normalize((xAxis[0], xAxis[1], 0) if xAxis else (1, 0, 0))
        _zAxis = (0, 0, 1)
        _yAxis = vectormath.crossProduct(_zAxis, _xAxis)
        vertices = tuple(
            vectormath.move(origin,
                            vectormath.sums((vectormath.scale(_xAxis, i *  width),
                                            vectormath.scale(_yAxis, j *  length),
                                            vectormath.scale(_zAxis, k *  height))
                            ))
            for i in range(2) for j in range(2) for k in range(2))

        return cls.fromVertices(vertices, convertToMeters, nDivXYZ, grading,
                                xAxis)
Exemple #2
0
 def __calculate2dPoints(v, o, n, w):
     # project point
     p = vectormath.project(v, o, n)
     # move the projected point backwards for half of the width
     t = vectormath.scale(vectormath.normalize(vectormath.subtract(v, p)),
                          w / 2.0)
     return vectormath.move(p, t)
 def __calculate2dPoints(v, o, n, w):
     # project point
     p = vectormath.project(v, o, n)
     # move the projected point backwards for half of the width
     t = vectormath.scale(vectormath.normalize(vectormath.subtract(v, p)),
                          w / 2.0)
     return vectormath.move(p, t)
    def fromMinMax(cls, minPt, maxPt, convertToMeters=1, nDivXYZ=None, grading=None,
                   xAxis=None):
        """Create BlockMeshDict from minimum and maximum point.

        Args:
            minPt: Minimum point of bounding box as (x, y, z).
            maxPt: Maximum point of bounding box as (x, y, z).
            convertToMeters: Scaling factor for the vertex coordinates.
            nDivXYZ: Number of divisions in (x, y, z) as a tuple (default: 5, 5, 5).
            grading: A simpleGrading (default: simpleGrading(1, 1, 1)).
            xAxis: An optional tuple that indicates the xAxis direction
                (default: (1, 0)).
        """
        _xAxis = vectormath.normalize((xAxis[0], xAxis[1], 0) if xAxis else (1, 0, 0))
        _zAxis = (0, 0, 1)
        _yAxis = vectormath.crossProduct(_zAxis, _xAxis)
        diagonal2D = tuple(i - j for i, j in zip(maxPt, minPt))[:2]
        _angle = radians(vectormath.angleAnitclockwise(_xAxis[:2], diagonal2D))
        width = cos(_angle) * vectormath.length(diagonal2D)
        length = sin(_angle) * vectormath.length(diagonal2D)
        height = maxPt[2] - minPt[2]

        vertices = tuple(
            vectormath.move(minPt,
                            vectormath.sums((vectormath.scale(_xAxis, i *  width),
                                            vectormath.scale(_yAxis, j *  length),
                                            vectormath.scale(_zAxis, k *  height))
                            ))
            for i in range(2) for j in range(2) for k in range(2))

        return cls.fromVertices(vertices, convertToMeters, nDivXYZ, grading,
                                xAxis)
Exemple #5
0
    def getMovement(self):
        dx, dy, dz, rotationAngle = (0, 0, 0, 0)

        #move to ball/square border intersection
        currentPosition = self.body.getPosition()
        target = self.target.getPosition()

        if (target[0]-currentPosition[0]) * (target[0]-currentPosition[0]) +  \
           (target[2]-currentPosition[2]) * (target[2]-currentPosition[2]) < 2.0 and \
           currentPosition[1]<1.1:
            dy = 2.0

        if vectormath.isPointInSquare(target, self.min, self.max):
            targetPosition = target
        else:
            targetPosition = vectormath.getBallAndSquareIntersection(
                target, self.target.getLinearVel(), self.min, self.max)
        targetPosition = (targetPosition[0] + random() - 0.5,
                          targetPosition[1],
                          targetPosition[2] + random() - 0.5)

        vectorAB = vectormath.getVector(currentPosition, targetPosition)

        #to make oponents run to ball coords - self length
        vABAngle = atan2(vectorAB[2], vectorAB[0])

        vABMagnitude = vectormath.getMagnitudeV(vectorAB)

        newVABMagnitude = vABMagnitude - 2.0  #malas garums/2

        newVABX = [
            cos(vABAngle) * newVABMagnitude, vectorAB[1],
            sin(vABAngle) * newVABMagnitude
        ]

        vectorAB = newVABX

        if vABMagnitude < 1.8:
            moveSpeed = 700 * self.body.getMass().mass
        else:
            moveSpeed = 4000 * self.body.getMass().mass

        currentRotationTuple = self.body.getRotation()
        currentRotation = currentRotationTuple[2], currentRotationTuple[
            5], currentRotationTuple[8]

        vectorAB = vectormath.normalize(vectorAB[0], 0, vectorAB[2])

        rotationAngle = vectormath.getAngleBetweenVectors(
            currentRotation, vectorAB)

        currentRotation = vectormath.negate(currentRotation)

        dx = currentRotation[0]
        dz = currentRotation[2]

        #/------------------

        return dx * moveSpeed, dy * moveSpeed, dz * moveSpeed, rotationAngle * moveSpeed
Exemple #6
0
 def x_axis(self):
     """X axis as a tuple."""
     if self._x_axis:
         return self._x_axis
     else:
         self._x_axis = vectormath.normalize(
             vectormath.subtract(self.vertices[1], self.vertices[0]))
     return self._x_axis
  def getMovement(self):
    dx, dy, dz, rotationAngle = (0,0,0,0)

    #move to ball/square border intersection
    currentPosition = self.body.getPosition()
    target = self.target.getPosition()

    if (target[0]-currentPosition[0]) * (target[0]-currentPosition[0]) +  \
       (target[2]-currentPosition[2]) * (target[2]-currentPosition[2]) < 2.0 and \
       currentPosition[1]<1.1:
      dy = 2.0
      
    if vectormath.isPointInSquare(target, self.min, self.max):
      targetPosition = target
    else:
      targetPosition = vectormath.getBallAndSquareIntersection(target,
                                                               self.target.getLinearVel(),
                                                               self.min,
                                                               self.max)  
    targetPosition = (targetPosition[0] + random() - 0.5, targetPosition[1], targetPosition[2] + random() - 0.5)
    
    vectorAB = vectormath.getVector(currentPosition, targetPosition)

    #to make oponents run to ball coords - self length
    vABAngle = atan2(vectorAB[2], vectorAB[0])

    vABMagnitude = vectormath.getMagnitudeV(vectorAB)

    newVABMagnitude = vABMagnitude - 2.0 #malas garums/2

    newVABX = [cos(vABAngle) * newVABMagnitude, vectorAB[1], sin(vABAngle) * newVABMagnitude]

    vectorAB = newVABX
    
    if vABMagnitude<1.8:
      moveSpeed = 700 * self.body.getMass().mass
    else:
      moveSpeed = 4000 * self.body.getMass().mass
    
    currentRotationTuple = self.body.getRotation()
    currentRotation = currentRotationTuple[2], currentRotationTuple[5], currentRotationTuple[8]

    vectorAB = vectormath.normalize(vectorAB[0], 0, vectorAB[2])    

    rotationAngle = vectormath.getAngleBetweenVectors(currentRotation, vectorAB)

    currentRotation = vectormath.negate(currentRotation)

    dx = currentRotation[0]
    dz = currentRotation[2]


    #/------------------

    return dx * moveSpeed, dy * moveSpeed, dz * moveSpeed, rotationAngle * moveSpeed
Exemple #8
0
def getPosition(avatar, pos, bone1, bone2, state, limit):

	#figure out which state we are in, and change the bone we are rotating
	dir = array(pos) - array(avatar.getBone(bone1).getPosition(viz.ABS_GLOBAL));		
	#if the hands are swapped
	if(STATE == 1):
		oriPosition = array(avatar.getBone(bone2).getPosition(viz.ABS_GLOBAL));
	else:
		oriPosition = array(avatar.getBone(bone1).getPosition(viz.ABS_GLOBAL));
	
	dir_len = dir.dot(dir);
	dir_len = math.sqrt(dir_len);
	
	#normalize the direction given by ppt
	dir_norm = vectormath.normalize(dir);
		
	posArray = oriPosition + dir;
	pos = [posArray[0], posArray[1], posArray[2]];
	
	#print "state: " + str(state);
	#if range of arms are limited
	if(state == 1):
		
		
		a = dir;
		#print "dir: " + str(dir);
		#a = array([-1, 1, 1]);
		a_len = a.dot(a);
		a_len = math.sqrt(a_len);
		#doing spherical coordinates, getting the radius first
		r = a_len;
		
		theta = math.acos(-a[1] / r);
		phi = math.atan2(a[0], a[2]);
		
		#print "theta: " + str(theta * 180 / math.pi);
		#print "phi: " + str(phi * 180 / math.pi);
		
		theta = theta * limit;
		
		#print "new theta: " + str(theta);
		
		y = -r * math.cos(theta);

		x = r * math.sin(phi) * math.sin(theta);
		z = r * math.cos(phi) * math.sin(theta);
		
		newDir = array([x, y, z]);
		pos = oriPosition + newDir;
		#print "newPos: " + str(pos);

	return pos;	
Exemple #9
0
    def make2d(self, planeOrigin, planeNormal, width=0.1):
        """Make the blockMeshDict two dimensional.

        Args:
            planeOrigin: Plane origin as (x, y, z).
            planeNormal: Plane normal as (x, y, z).
            width: width of 2d blockMeshDict (default: 01).
        """
        # copy original vertices
        if not self.__original3dVertices:
            self.__original3dVertices = self.vertices
        else:
            # load original 3d vertices
            self.make3d()

        n = vectormath.normalize(planeNormal)

        # project all vertices to plane and move them in direction of normal
        # by half of width
        self.__vertices = [
            self.__calculate2dPoints(v, planeOrigin, n, width)
            for v in self.vertices
        ]

        # set boundary condition to empty
        # and number of divisions to 1 in shortest side
        minimum = min(self.width, self.length, self.height)
        if self.width == minimum:
            self.nDivXYZ = (1, self.nDivXYZ[1], self.nDivXYZ[2])
            self.__is2dInXDir = True
            # set both sides to empty
            self.__setBoundaryToEmpty(4)
            self.__setBoundaryToEmpty(5)

        elif self.length == minimum:
            self.nDivXYZ = (self.nDivXYZ[0], 1, self.nDivXYZ[2])
            self.__is2dInYDir = True
            # set inlet and outlet to empty
            self.__setBoundaryToEmpty(0)
            self.__setBoundaryToEmpty(1)

        elif self.height == minimum:
            self.nDivXYZ = (self.nDivXYZ[0], self.nDivXYZ[1], 1)
            self.__is2dInZDir = True
            # set top and bottom to empty
            self.__setBoundaryToEmpty(2)
            self.__setBoundaryToEmpty(3)
Exemple #10
0
    def from_min_max(cls,
                     min_pt,
                     max_pt,
                     convertToMeters=1,
                     n_div_xyz=None,
                     grading=None,
                     x_axis=None):
        """Create BlockMeshDict from minimum and maximum point.

        Args:
            min_pt: Minimum point of bounding box as (x, y, z).
            max_pt: Maximum point of bounding box as (x, y, z).
            convertToMeters: Scaling factor for the vertex coordinates.
            n_div_xyz: Number of divisions in (x, y, z) as a tuple (default: 5, 5, 5).
            grading: A simpleGrading (default: simpleGrading(1, 1, 1)).
            x_axis: An optional tuple that indicates the x_axis direction
                (default: (1, 0)).
        """
        _x_axis = vectormath.normalize((x_axis[0], x_axis[1],
                                        0) if x_axis else (1, 0, 0))
        _z_axis = (0, 0, 1)
        _y_axis = vectormath.cross_product(_z_axis, _x_axis)
        diagonal2_d = tuple(i - j for i, j in zip(max_pt, min_pt))[:2]
        _angle = radians(
            vectormath.angle_anitclockwise(_x_axis[:2], diagonal2_d))
        width = cos(_angle) * vectormath.length(diagonal2_d)
        length = sin(_angle) * vectormath.length(diagonal2_d)
        height = max_pt[2] - min_pt[2]

        vertices = [
            vectormath.move(
                min_pt,
                vectormath.sums((vectormath.scale(_x_axis, i * width),
                                 vectormath.scale(_y_axis, j * length),
                                 vectormath.scale(_z_axis, k * height))))
            for i in range(2) for j in range(2) for k in range(2)
        ]

        return cls.from_vertices(vertices, convertToMeters, n_div_xyz, grading,
                                 x_axis)
Exemple #11
0
    def fromOriginAndSize(cls,
                          origin,
                          width,
                          length,
                          height,
                          convertToMeters=1,
                          nDivXYZ=None,
                          grading=None,
                          xAxis=None):
        """Create BlockMeshDict from BFBlockGeometries.

        Args:
            origin: Minimum point of bounding box as (x, y, z).
            width: Width in x direction.
            length: Length in y direction.
            height: Height in y direction.
            convertToMeters: Scaling factor for the vertex coordinates.
            nDivXYZ: Number of divisions in (x, y, z) as a tuple (default: 5, 5, 5).
            grading: A simpleGrading (default: simpleGrading(1, 1, 1)).
            xAxis: An optional tuple that indicates the xAxis direction
                (default: (1, 0)).
        """
        _xAxis = vectormath.normalize((xAxis[0], xAxis[1],
                                       0) if xAxis else (1, 0, 0))
        _zAxis = (0, 0, 1)
        _yAxis = vectormath.crossProduct(_zAxis, _xAxis)
        vertices = [
            vectormath.move(
                origin,
                vectormath.sums((vectormath.scale(_xAxis, i * width),
                                 vectormath.scale(_yAxis, j * length),
                                 vectormath.scale(_zAxis, k * height))))
            for i in range(2) for j in range(2) for k in range(2)
        ]

        return cls.fromVertices(vertices, convertToMeters, nDivXYZ, grading,
                                xAxis)
    def make2d(self, planeOrigin, planeNormal, width=0.1):
        """Create a new 2D blockMeshDict from this blockMeshDict.

        Args:
            planeOrigin: Plane origin as (x, y, z).
            planeNormal: Plane normal as (x, y, z).
            width: width of 2d blockMeshDict (default: 01).
        """
        # duplicate blockMeshDict
        bmd = self.duplicate()
        n = vectormath.normalize(planeNormal)

        # project all vertices to plane and move them in direction of normal
        # by half of width
        bmd.__vertices = tuple(
            self.__calculate2dPoints(v, planeOrigin, n, width)
            for v in bmd.vertices)

        # set boundary condition to empty
        # and number of divisions to 1 in shortest side
        minimum = min(bmd.width, bmd.length, bmd.height)
        if bmd.width == minimum:
            bmd.nDivXYZ = (1, bmd.nDivXYZ[1], bmd.nDivXYZ[2])
            # set both sides to empty

        elif bmd.length == minimum:
            bmd.nDivXYZ = (bmd.nDivXYZ[0], 1, bmd.nDivXYZ[2])
            # set inlet and outlet to empty
            # bmd.inlet.boundaryCondition = Empty()

        elif bmd.height == minimum:
            bmd.nDivXYZ = (bmd.nDivXYZ[0], bmd.nDivXYZ[1], 1)
            # set top and bottom to empty

        print('WARNING: make2d doesn\'t update boundary conditions to Empty.')
        return bmd
    def make2d(self, planeOrigin, planeNormal, width=0.1):
        """Create a new 2D blockMeshDict from this blockMeshDict.

        Args:
            planeOrigin: Plane origin as (x, y, z).
            planeNormal: Plane normal as (x, y, z).
            width: width of 2d blockMeshDict (default: 01).
        """
        # duplicate blockMeshDict
        bmd = self.duplicate()
        n = vectormath.normalize(planeNormal)

        # project all vertices to plane and move them in direction of normal
        # by half of width
        bmd.__vertices = tuple(
            self.__calculate2dPoints(v, planeOrigin, n, width)
            for v in bmd.vertices)

        # set boundary condition to empty
        # and number of divisions to 1 in shortest side
        minimum = min(bmd.width, bmd.length, bmd.height)
        if bmd.width == minimum:
            bmd.nDivXYZ = (1, bmd.nDivXYZ[1], bmd.nDivXYZ[2])
            # set both sides to empty

        elif bmd.length == minimum:
            bmd.nDivXYZ = (bmd.nDivXYZ[0], 1, bmd.nDivXYZ[2])
            # set inlet and outlet to empty
            # bmd.inlet.boundaryCondition = Empty()

        elif bmd.height == minimum:
            bmd.nDivXYZ = (bmd.nDivXYZ[0], bmd.nDivXYZ[1], 1)
            # set top and bottom to empty

        print('WARNING: make2d doesn\'t update boundary conditions to Empty.')
        return bmd
Exemple #14
0
    def fromGeometriesWindVectorAndParameters(cls,
                                              name,
                                              geometries,
                                              windVector,
                                              tunnelParameters,
                                              roughness,
                                              meshingParameters=None,
                                              Zref=None,
                                              convertToMeters=1):
        """Create a windTunnel based on size, wind speed and wind direction."""
        # butterfly geometries
        geos = tuple(cls.__checkInputGeometry(geo) for geo in geometries)

        # update boundary condition of wall geometries
        for bfGeometry in geometries:
            bfGeometry.boundaryCondition = WindTunnelWallBoundaryCondition()

        tp = tunnelParameters

        # find xAxis
        # project wind vector to XY Plane
        windVector = (windVector[0], windVector[1], 0)
        zAxis = (0, 0, 1)
        xAxis = vm.crossProduct(windVector, zAxis)
        yAxis = vm.normalize(windVector)

        # get size of bounding box from blockMeshDict
        minPt, maxPt = calculateMinMaxFromBFGeometries(geos, xAxis)
        _blockMeshDict = BlockMeshDict.fromMinMax(minPt,
                                                  maxPt,
                                                  convertToMeters,
                                                  xAxis=xAxis)
        # scale based on wind tunnel parameters
        ver = _blockMeshDict.vertices
        height = _blockMeshDict.height
        v0 = vm.move(ver[0], vm.scale(yAxis, -tp.windward * height))
        v0 = vm.move(v0, vm.scale(xAxis, -tp.side * height))
        v1 = vm.move(ver[1], vm.scale(yAxis, -tp.windward * height))
        v1 = vm.move(v1, vm.scale(xAxis, tp.side * height))
        v2 = vm.move(ver[2], vm.scale(yAxis, tp.leeward * height))
        v2 = vm.move(v2, vm.scale(xAxis, tp.side * height))
        v3 = vm.move(ver[3], vm.scale(yAxis, tp.leeward * height))
        v3 = vm.move(v3, vm.scale(xAxis, -tp.side * height))
        v4 = vm.move(v0, vm.scale(zAxis, tp.top * height))
        v5 = vm.move(v1, vm.scale(zAxis, tp.top * height))
        v6 = vm.move(v2, vm.scale(zAxis, tp.top * height))
        v7 = vm.move(v3, vm.scale(zAxis, tp.top * height))

        # create inlet, outlet, etc
        ablConditions = ABLConditions.fromInputValues(
            flowSpeed=vm.length(windVector),
            z0=roughness,
            flowDir=vm.normalize(windVector),
            zGround=_blockMeshDict.minZ)

        _order = (range(4), )
        inlet = BFBlockGeometry(
            'inlet', (v0, v1, v5, v4), _order, ((v0, v1, v5, v4), ),
            WindTunnelInletBoundaryCondition(ablConditions))

        outlet = BFBlockGeometry('outlet', (v2, v3, v7, v6), _order,
                                 ((v2, v3, v7, v6), ),
                                 WindTunnelOutletBoundaryCondition())

        rightSide = BFBlockGeometry('rightSide', (v1, v2, v6, v5), _order,
                                    ((v1, v2, v6, v5), ),
                                    WindTunnelTopAndSidesBoundaryCondition())

        leftSide = BFBlockGeometry('leftSide', (v3, v0, v4, v7), _order,
                                   ((v3, v0, v4, v7), ),
                                   WindTunnelTopAndSidesBoundaryCondition())

        top = BFBlockGeometry('top', (v4, v5, v6, v7), _order,
                              ((v4, v5, v6, v7), ),
                              WindTunnelTopAndSidesBoundaryCondition())

        ground = BFBlockGeometry(
            'ground', (v3, v2, v1, v0), (range(4), ), ((v3, v2, v1, v0), ),
            WindTunnelGroundBoundaryCondition(ablConditions))

        # return the class
        wt = cls(name, inlet, outlet, (rightSide, leftSide), top, ground,
                 geometries, roughness, meshingParameters, Zref,
                 convertToMeters)

        return wt
    def fromGeometriesWindVectorAndParameters(
            cls, name, geometries, windVector, tunnelParameters, roughness,
            meshingParameters=None, Zref=None, convertToMeters=1):
        """Create a windTunnel based on size, wind speed and wind direction."""
        # butterfly geometries
        geos = tuple(cls.__checkInputGeometry(geo) for geo in geometries)

        # update boundary condition of wall geometries
        for bfGeometry in geometries:
            bfGeometry.boundaryCondition = WindTunnelWallBoundaryCondition(
                bfGeometry.boundaryCondition.refLevels
            )

        tp = tunnelParameters

        # find xAxis
        # project wind vector to XY Plane
        windVector = (windVector[0], windVector[1], 0)
        zAxis = (0, 0, 1)
        xAxis = vm.crossProduct(windVector, zAxis)
        yAxis = vm.normalize(windVector)

        # get size of bounding box from blockMeshDict
        minPt, maxPt = calculateMinMaxFromBFGeometries(geos, xAxis)
        _blockMeshDict = BlockMeshDict.fromMinMax(minPt, maxPt, convertToMeters,
                                                  xAxis=xAxis)
        # scale based on wind tunnel parameters
        ver = _blockMeshDict.vertices
        height = _blockMeshDict.height
        v0 = vm.move(ver[0], vm.scale(yAxis, -tp.windward * height))
        v0 = vm.move(v0, vm.scale(xAxis, -tp.side * height))
        v1 = vm.move(ver[1], vm.scale(yAxis, -tp.windward * height))
        v1 = vm.move(v1, vm.scale(xAxis, tp.side * height))
        v2 = vm.move(ver[2], vm.scale(yAxis, tp.leeward * height))
        v2 = vm.move(v2, vm.scale(xAxis, tp.side * height))
        v3 = vm.move(ver[3], vm.scale(yAxis, tp.leeward * height))
        v3 = vm.move(v3, vm.scale(xAxis, -tp.side * height))
        v4 = vm.move(v0, vm.scale(zAxis, tp.top * height))
        v5 = vm.move(v1, vm.scale(zAxis, tp.top * height))
        v6 = vm.move(v2, vm.scale(zAxis, tp.top * height))
        v7 = vm.move(v3, vm.scale(zAxis, tp.top * height))

        # create inlet, outlet, etc
        ablConditions = ABLConditions.fromInputValues(
            flowSpeed=vm.length(windVector), z0=roughness,
            flowDir=vm.normalize(windVector), zGround=_blockMeshDict.minZ)

        _order = (range(4),)
        inlet = BFBlockGeometry(
            'inlet', (v0, v1, v5, v4), _order, ((v0, v1, v5, v4),),
            WindTunnelInletBoundaryCondition(ablConditions))

        outlet = BFBlockGeometry(
            'outlet', (v2, v3, v7, v6), _order, ((v2, v3, v7, v6),),
            WindTunnelOutletBoundaryCondition())

        rightSide = BFBlockGeometry(
            'rightSide', (v1, v2, v6, v5), _order, ((v1, v2, v6, v5),),
            WindTunnelTopAndSidesBoundaryCondition())

        leftSide = BFBlockGeometry(
            'leftSide', (v3, v0, v4, v7), _order, ((v3, v0, v4, v7),),
            WindTunnelTopAndSidesBoundaryCondition())

        top = BFBlockGeometry('top', (v4, v5, v6, v7), _order,
                              ((v4, v5, v6, v7),),
                              WindTunnelTopAndSidesBoundaryCondition())

        ground = BFBlockGeometry(
            'ground', (v3, v2, v1, v0), (range(4),), ((v3, v2, v1, v0),),
            WindTunnelGroundBoundaryCondition(ablConditions))

        # return the class
        wt = cls(name, inlet, outlet, (rightSide, leftSide), top, ground,
                 geometries, roughness, meshingParameters, Zref,
                 convertToMeters)

        return wt
Exemple #16
0
 def x_axis(self, v):
     """X axis."""
     v = v or (1, 0, 0)
     self._x_axis = vectormath.normalize((v[0], v[1], 0))