Ejemplo n.º 1
0
    def execute(self, obj):
        if isDerivedFrom(obj, "Part::FeaturePython"):
            obj.Shape = Shapes.reshape(obj.Source.Shape)
            obj.Placement = spexpr2fcexpr(self.getSymPyTransformation(obj))

            obj.Outfaces = trace(obj) if P.autotrace else []

        elif isDerivedFrom(obj, "Mesh::FeaturePython"):
            obj.Mesh = meshOf(obj.Source, remeshed=True)
            obj.Placement = spexpr2fcexpr(self.getSymPyTransformation(obj))

        else:
            raise TypeError
Ejemplo n.º 2
0
def construct(zet, mbb, margin=1e-03, fn=50):
    if zet is None:
        return Mesh.Mesh()

    elif isinstance(zet, Intersection):
        return common(construct(arg, mbb, margin, fn) for arg in zet.args)

    elif isinstance(zet, Union):
        return fuse(construct(arg, mbb, margin, fn) for arg in zet.args)

    elif isinstance(zet, Complement):
        return common([construct(zet.arg[0], mbb, margin, fn),
                       complement(construct(zet.arg[1], mbb, margin, fn))])

    elif isinstance(zet, AbsoluteComplement):
        return complement(construct(zet.arg[0], mbb, margin, fn))

    elif isinstance(zet, Image):
        placement = spexpr2fcexpr(zet.function)
        mbb_ = mbb.transformed(placement.inverse().toMatrix())
        return transform(construct(zet.set, mbb_, margin, fn), zet.function)

    elif isinstance(zet, euclid.EmptySpace):
        return Mesh.Mesh()

    elif isinstance(zet, euclid.WholeSpace):
        mesh = Mesh.createSphere(mbb.DiagonalLength/2 + margin, int(fn))
        mesh.translate(*mbb.Center)
        return mesh

    elif isinstance(zet, euclid.Halfspace):
        direction = spexpr2fcexpr(zet.direction)
        offset = spexpr2fcexpr(zet.offset)
        if not mbb.isCutPlane(direction*offset, direction):
            return direction*mbb.Center > offset

        rot = rmat_k2d(zet.direction)
        center = zet.direction*zet.offset
        placement = spexpr2fcexpr(AffineTransformation(matrix=rot, vector=center))

        mbb_ = mbb.transformed(placement.inverse().toMatrix())
        height = mbb_.ZMax + margin
        xm = max(abs(mbb_.XMax), abs(mbb_.XMin))
        ym = max(abs(mbb_.YMax), abs(mbb_.YMin))
        radius = math.sqrt(xm**2 + ym**2) + margin
        mesh = createConicalFrustum(radius, radius, height, fn=fn)
        mesh.Placement = placement
        return mesh

    elif isinstance(zet, euclid.InfiniteCylinder):
        direction = spexpr2fcexpr(zet.direction)
        center = spexpr2fcexpr(zet.center)
        dist = mbb.Center.distanceToLine(center, direction)
        radius = spexpr2fcexpr(zet.radius)
        mbb_radius = mbb.DiagonalLength/2
        if radius + mbb_radius < dist:
            return False
        elif radius - mbb_radius > dist:
            return True

        rot = rmat_k2d(zet.direction)
        placement = spexpr2fcexpr(AffineTransformation(matrix=rot, vector=zet.center))

        mbb_ = mbb.transformed(placement.inverse().toMatrix())
        height = mbb_.ZLength + 2*margin
        bottom = FreeCAD.Vector(0, 0, mbb_.ZMin-margin)
        mesh = createConicalFrustum(radius, radius, height, bottom, fn=fn)
        mesh.Placement = placement
        return mesh

    elif isinstance(zet, euclid.SemiInfiniteCone):
        pnt = mbb.Center - spexpr2fcexpr(zet.center)
        mbb_radius = mbb.DiagonalLength/2
        if pnt.Length > mbb_radius:
            direction = spexpr2fcexpr(zet.direction)
            ang = abs(math.acos(direction*pnt/pnt.Length))
            ang_cone = math.atan(spexpr2fcexpr(zet.slope))
            ang_ball = math.asin(mbb_radius/pnt.Length)
            if ang_cone + ang_ball < ang:
                return False
            elif ang_cone - ang_ball > ang:
                return True

        rot = rmat_k2d(zet.direction)
        placement = spexpr2fcexpr(AffineTransformation(matrix=rot, vector=zet.center))

        mbb_ = mbb.transformed(placement.inverse().toMatrix())
        height = mbb_.ZLength + margin
        radius = height*spexpr2fcexpr(zet.slope)
        mesh = createConicalFrustum(0, radius, height, fn=fn)
        mesh.Placement = placement
        return mesh

    elif isinstance(zet, euclid.Sphere):
        radius = spexpr2fcexpr(zet.radius)
        mesh = Mesh.createSphere(radius, int(fn))

        placement = spexpr2fcexpr(AffineTransformation(vector=zet.center))
        mesh.Placement = placement
        return mesh

    elif isinstance(zet, euclid.Box):
        size = spexpr2fcexpr(zet.size)
        mesh = Mesh.createBox(size.x, size.y, size.z)

        rot = zet.orientation
        placement = spexpr2fcexpr(AffineTransformation(matrix=rot, vector=zet.center))
        mesh.Placement = placement

        return mesh

    elif isinstance(zet, euclid.Cylinder):
        radius = spexpr2fcexpr(zet.radius)
        height = spexpr2fcexpr(zet.height)
        pnt = FreeCAD.Vector(0, 0, -height/2)
        mesh = createConicalFrustum(radius, radius, height, pnt, fn=fn)

        rot = rmat_k2d(zet.direction)
        placement = spexpr2fcexpr(AffineTransformation(matrix=rot, vector=zet.center))
        mesh.Placement = placement

        return mesh

    elif isinstance(zet, euclid.Cone):
        radius = spexpr2fcexpr(zet.radius)
        height = spexpr2fcexpr(zet.height)
        mesh = createConicalFrustum(0, radius, height, fn=fn)

        rot = rmat_k2d(zet.direction)
        placement = spexpr2fcexpr(AffineTransformation(matrix=rot, vector=zet.center))
        mesh.Placement = placement

        return mesh

    else:
        raise TypeError
Ejemplo n.º 3
0
def transform(shp, trans):
    shp = reshape(shp)
    shp.Placement = spexpr2fcexpr(trans)
    return shp
Ejemplo n.º 4
0
def transform(mesh, trans):
    mesh = remesh(mesh)
    mesh.Placement = spexpr2fcexpr(trans)
    return mesh