Beispiel #1
0
 def attach(self,vobj):
     '''Setup the scene sub-graph of the view provider'''
     self.arrow = coin.SoSeparator()
     self.arrowpos = coin.SoTransform()
     self.arrow.addChild(self.arrowpos)
     self.matline = coin.SoMaterial()
     self.drawstyle = coin.SoDrawStyle()
     self.drawstyle.style = coin.SoDrawStyle.LINES
     self.lcoords = coin.SoCoordinate3()
     self.line = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
     self.mattext = coin.SoMaterial()
     textdrawstyle = coin.SoDrawStyle()
     textdrawstyle.style = coin.SoDrawStyle.FILLED
     self.textpos = coin.SoTransform()
     self.font = coin.SoFont()
     self.text2d = coin.SoText2()
     self.text3d = coin.SoAsciiText()
     self.text2d.string = self.text3d.string = "Label" # need to init with something, otherwise, crash!
     self.text2d.justification = coin.SoText2.RIGHT
     self.text3d.justification = coin.SoAsciiText.RIGHT
     self.fcoords = coin.SoCoordinate3()
     self.frame = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
     self.lineswitch = coin.SoSwitch()
     switchnode = coin.SoSeparator()
     switchnode.addChild(self.line)
     switchnode.addChild(self.arrow)
     self.lineswitch.addChild(switchnode)
     self.lineswitch.whichChild = 0
     self.node2d = coin.SoGroup()
     self.node2d.addChild(self.matline)
     self.node2d.addChild(self.arrow)
     self.node2d.addChild(self.drawstyle)
     self.node2d.addChild(self.lcoords)
     self.node2d.addChild(self.lineswitch)
     self.node2d.addChild(self.mattext)
     self.node2d.addChild(textdrawstyle)
     self.node2d.addChild(self.textpos)
     self.node2d.addChild(self.font)
     self.node2d.addChild(self.text2d)
     self.node2d.addChild(self.fcoords)
     self.node2d.addChild(self.frame)
     self.node3d = coin.SoGroup()
     self.node3d.addChild(self.matline)
     self.node3d.addChild(self.arrow)
     self.node3d.addChild(self.drawstyle)
     self.node3d.addChild(self.lcoords)
     self.node3d.addChild(self.lineswitch)
     self.node3d.addChild(self.mattext)
     self.node3d.addChild(textdrawstyle)
     self.node3d.addChild(self.textpos)
     self.node3d.addChild(self.font)
     self.node3d.addChild(self.text3d)
     self.node3d.addChild(self.fcoords)
     self.node3d.addChild(self.frame)
     vobj.addDisplayMode(self.node2d,"2D text")
     vobj.addDisplayMode(self.node3d,"3D text")
     self.onChanged(vobj,"LineColor")
     self.onChanged(vobj,"TextColor")
     self.onChanged(vobj,"ArrowSize")
     self.onChanged(vobj,"Line")
Beispiel #2
0
    def onChanged(self,vobj,prop):

        if prop == "ShowNodes":
            if hasattr(self,"nodes"):
                vobj.Annotation.removeChild(self.nodes)
                del self.nodes
            if vobj.ShowNodes:
                from pivy import coin
                self.nodes = coin.SoAnnotation()
                self.coords = coin.SoCoordinate3()
                self.mat = coin.SoMaterial()
                self.pointstyle = coin.SoDrawStyle()
                self.pointstyle.style = coin.SoDrawStyle.POINTS
                self.pointset = coin.SoType.fromName("SoBrepPointSet").createInstance()
                self.linestyle = coin.SoDrawStyle()
                self.linestyle.style = coin.SoDrawStyle.LINES
                self.lineset = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
                self.facestyle = coin.SoDrawStyle()
                self.facestyle.style = coin.SoDrawStyle.FILLED
                self.shapehints = coin.SoShapeHints()
                self.shapehints.faceType = coin.SoShapeHints.UNKNOWN_FACE_TYPE
                self.fmat = coin.SoMaterial()
                self.fmat.transparency.setValue(0.75)
                self.faceset = coin.SoIndexedFaceSet()
                self.nodes.addChild(self.coords)
                self.nodes.addChild(self.mat)
                self.nodes.addChild(self.pointstyle)
                self.nodes.addChild(self.pointset)
                self.nodes.addChild(self.linestyle)
                self.nodes.addChild(self.lineset)
                self.nodes.addChild(self.facestyle)
                self.nodes.addChild(self.shapehints)
                self.nodes.addChild(self.fmat)
                self.nodes.addChild(self.faceset)
                vobj.Annotation.addChild(self.nodes)
                self.updateData(vobj.Object,"Nodes")
                self.onChanged(vobj,"NodeColor")
                self.onChanged(vobj,"NodeLine")
                self.onChanged(vobj,"NodeSize")

        elif prop == "NodeColor":
            if hasattr(self,"mat"):
                l = vobj.NodeColor
                self.mat.diffuseColor.setValue([l[0],l[1],l[2]])
                self.fmat.diffuseColor.setValue([l[0],l[1],l[2]])

        elif prop == "NodeLine":
            if hasattr(self,"linestyle"):
                self.linestyle.lineWidth = vobj.NodeLine

        elif prop == "NodeSize":
            if hasattr(self,"pointstyle"):
                self.pointstyle.pointSize = vobj.NodeSize

        elif prop == "NodeType":
            self.updateData(vobj.Object,"Nodes")

        else:
            ArchComponent.ViewProviderComponent.onChanged(self,vobj,prop)
Beispiel #3
0
    def _build_drag_line(self):
        """
        Build the drag line for drag operations
        """

        _m = coin.SoMarkerSet()

        _l = coin.SoLineSet()
        _l.numVertices.setValue(2)

        _d = coin.SoDrawStyle()
        _d.linePattern = 0x0f0f
        _d.lineWeight = 2

        _c = coin.SoBaseColor()
        _c.rgb = (0.8, 0.8, 1.0)

        _g = coin.SoGroup()
        _g.addChild(_d)
        _g.addChild(_c)
        _g.addChild(self.drag_line_coord)
        _g.addChild(_m)
        _g.addChild(_l)

        self.root.addChild(_g)
    def attach(self, vobj):

        self.Object = vobj.Object
        self.clip = None
        from pivy import coin
        self.sep = coin.SoGroup()
        self.mat = coin.SoMaterial()
        self.sep.addChild(self.mat)
        self.dst = coin.SoDrawStyle()
        self.sep.addChild(self.dst)
        self.lco = coin.SoCoordinate3()
        self.sep.addChild(self.lco)
        lin = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
        lin.coordIndex.setValues([0, 1, -1, 2, 3, -1, 4, 5, -1])
        self.sep.addChild(lin)
        self.tra = coin.SoTransform()
        self.tra.rotation.setValue(FreeCAD.Rotation(0, 0, 90).Q)
        self.sep.addChild(self.tra)
        self.fon = coin.SoFont()
        self.sep.addChild(self.fon)
        self.txt = coin.SoAsciiText()
        self.txt.justification = coin.SoText2.LEFT
        self.txt.string.setValue("level")
        self.sep.addChild(self.txt)
        vobj.addDisplayMode(self.sep, "Default")
        self.onChanged(vobj, "ShapeColor")
        self.onChanged(vobj, "FontName")
        self.onChanged(vobj, "ShowLevel")
        self.onChanged(vobj, "FontSize")
        return
Beispiel #5
0
    def _get_bspline(self):
        """
        returns a coin.SoNurbsCurve and the poles seperators
        set the pole-values by poels.point.setValues(0, 9, mat.tolist())
        """
        draw_style = coin.SoDrawStyle()
        draw_style.lineWidth = 2
        complexity = coin.SoComplexity()
        complexity.value = 1.
        spline_sep = coin.SoSeparator()
        upper_sep = coin.SoSeparator()
        lower_sep = coin.SoSeparator()
        knot_vector = 5 * [0] + [0.2, 0.4, 0.6, 0.8] + 5 * [1]
        upper_curve = coin.SoNurbsCurve()
        lower_curve = coin.SoNurbsCurve()
        upper_curve.knotVector.setValues(0, len(knot_vector), knot_vector)
        lower_curve.knotVector.setValues(0, len(knot_vector), knot_vector)
        upper_curve.numControlPoints = 9
        lower_curve.numControlPoints = 9
        upper_poles = coin.SoCoordinate4()
        lower_poles = coin.SoCoordinate4()
        upper_line_set = coin.SoLineSet()
        lower_line_set = coin.SoLineSet()

        # no need to set degree. Should be computed by numControlPoints and knotvector
        upper_sep += [
            complexity, upper_poles, upper_line_set, draw_style, upper_curve
        ]
        lower_sep += [
            complexity, lower_poles, lower_line_set, draw_style, lower_curve
        ]
        spline_sep += [upper_sep, lower_sep]
        return (spline_sep, upper_poles, lower_poles)
Beispiel #6
0
 def __init__(self, points, dynamic=False):
     super(Line, self).__init__(dynamic)
     self.drawstyle = coin.SoDrawStyle()
     self.line = coin.SoLineSet()
     self.points = points
     self.addChild(self.drawstyle)
     self.addChild(self.line)
Beispiel #7
0
 def attach(self,vobj):
     self.mat1 = coin.SoMaterial()
     self.mat2 = coin.SoMaterial()
     self.fcoords = coin.SoCoordinate3()
     #fs = coin.SoType.fromName("SoBrepFaceSet").createInstance() # this causes a FreeCAD freeze for me
     fs = coin.SoIndexedFaceSet()
     fs.coordIndex.setValues(0,7,[0,1,2,-1,0,2,3])
     self.drawstyle = coin.SoDrawStyle()
     self.drawstyle.style = coin.SoDrawStyle.LINES
     self.lcoords = coin.SoCoordinate3()
     ls = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
     ls.coordIndex.setValues(0,57,[0,1,-1,2,3,4,5,-1,6,7,8,9,-1,10,11,-1,12,13,14,15,-1,16,17,18,19,-1,20,21,-1,22,23,24,25,-1,26,27,28,29,-1,30,31,-1,32,33,34,35,-1,36,37,38,39,-1,40,41,42,43,44])
     sep = coin.SoSeparator()
     psep = coin.SoSeparator()
     fsep = coin.SoSeparator()
     fsep.addChild(self.mat2)
     fsep.addChild(self.fcoords)
     fsep.addChild(fs)
     psep.addChild(self.mat1)
     psep.addChild(self.drawstyle)
     psep.addChild(self.lcoords)
     psep.addChild(ls)
     sep.addChild(fsep)
     sep.addChild(psep)
     vobj.addDisplayMode(sep,"Default")
     self.onChanged(vobj,"DisplaySize")
     self.onChanged(vobj,"LineColor")
     self.onChanged(vobj,"Transparency")
Beispiel #8
0
 def __init__(self, color = (0.,0.,0.), lineWidth = 1.0, pointSize = 1.0):
     super(styleNode, self).__init__()
     self.drawStyle = coin.SoDrawStyle()
     self.addChild(self.drawStyle)
     self.color = color
     self.lineWidth = lineWidth
     self.pointSize = pointSize
Beispiel #9
0
    def __init__(self, name="GridView"):
        super(gridView, self).__init__()
        self.setName(name)
        self._number_of_points = 50
        self._center = (0, 0)
        self._scale = 1.0
        self._axis = 0  # 1=X 2=Y 3=Z
        self.transform = coin.SoTransform()
        self.coord = coin.SoCoordinate3()
        self.sep1 = coin.SoSeparator()
        self.sep1.setName("Snap_Points")
        self.sep2 = coin.SoSeparator()
        self.sep2.setName("Grid")
        self.sep3 = coin.SoSeparator()
        self.sep3.setName("Axis")
        self.addChild(self.transform)
        self.addChild(self.coord)
        self.addChild(self.sep1)
        self.addChild(self.sep2)
        self.addChild(self.sep3)

        ps = coin.SoPointSet()
        ds = coin.SoDrawStyle()
        ds.pointSize = 1
        self.sep1.addChild(ds)
        self.sep1.addChild(ps)

        self.color1 = (0.82, 0.15, 0.15)  # red (X)
        self.color2 = (0.40, 0.59, 0.20)  # green (Y)
        self.color3 = (0.13, 0.49, 0.88)  # blue (Z)
Beispiel #10
0
 def __init__(self,
              dotted=False,
              scolor=None,
              swidth=None,
              children=[],
              ontop=False,
              name=None):
     global Part, DraftGeomUtils
     import Part, DraftGeomUtils
     self.ontop = ontop
     color = coin.SoBaseColor()
     color.rgb = scolor or FreeCADGui.draftToolBar.getDefaultColor("ui")
     drawstyle = coin.SoDrawStyle()
     if swidth:
         drawstyle.lineWidth = swidth
     if dotted:
         drawstyle.style = coin.SoDrawStyle.LINES
         drawstyle.lineWeight = 3
         drawstyle.linePattern = 0x0f0f  #0xaa
     node = coin.SoSeparator()
     for c in [drawstyle, color] + children:
         node.addChild(c)
     self.switch = coin.SoSwitch()  # this is the on/off switch
     if name:
         self.switch.setName(name)
     self.switch.addChild(node)
     self.switch.whichChild = -1
     self.Visible = False
     from DraftGui import todo
     todo.delay(self._insertSwitch, self.switch)
Beispiel #11
0
    def build_axis(self):
        np = self._number_of_points
        n = 1 + 2 * np

        ds = coin.SoDrawStyle()
        ds.lineWidth = 2
        self.sep3.addChild(ds)

        self.mat1 = coin.SoMaterial()
        #bind1 = coin.SoMaterialBinding()
        #bind1.value = coin.SoMaterialBinding.PER_PART
        ax = coin.SoIndexedLineSet()
        ax.coordIndex.setValue(0)
        ax.coordIndex.setValues(0, 3, [n * np, n * (np + 1) - 1, -1])
        #self.sep3.addChild(bind1)
        self.sep3.addChild(self.mat1)
        self.sep3.addChild(ax)

        self.mat2 = coin.SoMaterial()
        #bind2 = coin.SoMaterialBinding()
        #bind2.value = coin.SoMaterialBinding.PER_PART
        ax2 = coin.SoIndexedLineSet()
        ax2.coordIndex.setValue(0)
        ax2.coordIndex.setValues(0, 3, [np, n * (n - 1) + np, -1])
        #self.sep3.addChild(bind2)
        self.sep3.addChild(self.mat2)
        self.sep3.addChild(ax2)
Beispiel #12
0
 def __init__(self, spGrp):
     self.__color     = coin.SoBaseColor()
     self.__drawStyle = coin.SoDrawStyle()
     spGrp.addChild(self.__color)
     spGrp.addChild(self.__drawStyle)
     self.__group = spGrp
     self.style()
Beispiel #13
0
 def setup_default_display_mode(self, vobj):
     """Setup the coin nodes of the placeholder representation of the Section Plane."""
     self.clip = None
     self.mat1 = coin.SoMaterial()
     self.mat2 = coin.SoMaterial()
     self.fcoords = coin.SoCoordinate3()
     #fs = coin.SoType.fromName("SoBrepFaceSet").createInstance() # this causes a FreeCAD freeze for me
     fs = coin.SoIndexedFaceSet()
     fs.coordIndex.setValues(0, 7, [0, 1, 2, -1, 0, 2, 3])
     self.drawstyle = coin.SoDrawStyle()
     self.drawstyle.style = coin.SoDrawStyle.LINES
     self.lcoords = coin.SoCoordinate3()
     ls = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
     ls.coordIndex.setValues(0, 57, [
         0, 1, -1, 2, 3, 4, 5, -1, 6, 7, 8, 9, -1, 10, 11, -1, 12, 13, 14,
         15, -1, 16, 17, 18, 19, -1, 20, 21, -1, 22, 23, 24, 25, -1, 26, 27,
         28, 29, -1, 30, 31, -1, 32, 33, 34, 35, -1, 36, 37, 38, 39, -1, 40,
         41, 42, 43, 44
     ])
     sep = coin.SoSeparator()
     psep = coin.SoSeparator()
     fsep = coin.SoSeparator()
     fsep.addChild(self.mat2)
     fsep.addChild(self.fcoords)
     fsep.addChild(fs)
     psep.addChild(self.mat1)
     psep.addChild(self.drawstyle)
     psep.addChild(self.lcoords)
     psep.addChild(ls)
     sep.addChild(fsep)
     sep.addChild(psep)
     vobj.addDisplayMode(sep, "Default")
Beispiel #14
0
 def attach(self,vobj):
     '''Setup the scene sub-graph of the view provider'''
     self.mattext = coin.SoMaterial()
     textdrawstyle = coin.SoDrawStyle()
     textdrawstyle.style = coin.SoDrawStyle.FILLED
     self.trans = coin.SoTransform()
     self.font = coin.SoFont()
     self.text2d = coin.SoAsciiText()
     self.text3d = coin.SoText2()
     self.text2d.string = self.text3d.string = "Label" # need to init with something, otherwise, crash!
     self.text2d.justification = coin.SoAsciiText.LEFT
     self.text3d.justification = coin.SoText2.LEFT
     self.node2d = coin.SoGroup()
     self.node2d.addChild(self.trans)
     self.node2d.addChild(self.mattext)
     self.node2d.addChild(textdrawstyle)
     self.node2d.addChild(self.font)
     self.node2d.addChild(self.text2d)
     self.node3d = coin.SoGroup()
     self.node3d.addChild(self.trans)
     self.node3d.addChild(self.mattext)
     self.node3d.addChild(textdrawstyle)
     self.node3d.addChild(self.font)
     self.node3d.addChild(self.text3d)
     vobj.addDisplayMode(self.node2d,"2D text")
     vobj.addDisplayMode(self.node3d,"3D text")
     self.onChanged(vobj,"TextColor")
     self.onChanged(vobj,"FontSize")
     self.onChanged(vobj,"FontName")
     self.onChanged(vobj,"Justification")
     self.onChanged(vobj,"LineSpacing")
Beispiel #15
0
    def __init__(self, names, children=None, select=True, group=False):
        """
        Constructor
        """
        self.visible = False
        self.select = select
        self.color = coin.SoBaseColor()
        self.draw_style = coin.SoDrawStyle()
        self.names = names
        self.node = coin.SoSeparator()
        self.parent = None

        if not children:
            children = []

        if group:
            self.node = coin.SoGroup()

        if self.select:

            self.node = \
                coin.SoType.fromName("SoFCSelection").createInstance()

            self.node.documentName.setValue(self.names[0])
            self.node.objectName.setValue(self.names[1])
            self.node.subElementName.setValue(self.names[2])

        for child in [self.draw_style, self.color] + children:
            self.node.addChild(child)
Beispiel #16
0
 def attach(self,vobj):
     self.clip = None
     self.mat1 = coin.SoMaterial()
     self.mat2 = coin.SoMaterial()
     self.fcoords = coin.SoCoordinate3()
     fs = coin.SoIndexedFaceSet()
     fs.coordIndex.setValues(0,7,[0,1,2,-1,0,2,3])
     self.drawstyle = coin.SoDrawStyle()
     self.drawstyle.style = coin.SoDrawStyle.LINES
     self.lcoords = coin.SoCoordinate3()
     ls = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
     ls.coordIndex.setValues(0,28,[0,1,-1,2,3,4,5,-1,6,7,-1,8,9,10,11,-1,12,13,-1,14,15,16,17,-1,18,19,20,21])
     sep = coin.SoSeparator()
     psep = coin.SoSeparator()
     fsep = coin.SoSeparator()
     fsep.addChild(self.mat2)
     fsep.addChild(self.fcoords)
     fsep.addChild(fs)
     psep.addChild(self.mat1)
     psep.addChild(self.drawstyle)
     psep.addChild(self.lcoords)
     psep.addChild(ls)
     sep.addChild(fsep)
     sep.addChild(psep)
     vobj.addDisplayMode(sep,"Default")
     self.onChanged(vobj,"DisplaySize")
     self.onChanged(vobj,"LineColor")
     self.onChanged(vobj,"Transparency")
     self.Object = vobj.Object
Beispiel #17
0
def draw_line(p1, p2, color, LineWidth):
    try:
        dash = coin.SoSeparator()
        v = coin.SoVertexProperty()
        v.vertex.set1Value(0, p1)
        v.vertex.set1Value(1, p2)
        coords = coin.SoTransform()
        line = coin.SoLineSet()
        line.vertexProperty = v
        style = coin.SoDrawStyle()
        style.lineWidth = LineWidth
        dash.addChild(style)
        col1 = coin.SoBaseColor()  # must be converted to SoBaseColor
        col1.rgb = color
        dash.addChild(col1)
        dash.addChild(line)
        dash.addChild(coords)
        return dash

    except Exception as err:
        App.Console.PrintError("'makeIt' Failed. "
                               "{err}\n".format(err=str(err)))
        exc_type, exc_obj, exc_tb = sys.exc_info()
        fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
        print(exc_type, fname, exc_tb.tb_lineno)
Beispiel #18
0
def draw_polygon(vertices, color, LineWidth):
    """
        Draw any polygon. This will be the base of all multi-point drawing.
        Curves, and arc is not here.
    """
    if len(vertices) < 4:
        raise ValueError('Vertices must be 4')
    _polygon = coin.SoSeparator()
    col = coin.SoBaseColor()
    col.rgb = color
    coords = coin.SoTransform()
    data = coin.SoCoordinate3()
    face = coin.SoIndexedFaceSet()
    style = coin.SoDrawStyle()
    style.lineWidth = LineWidth
    _polygon.addChild(style)
    _polygon.addChild(col)
    _polygon.addChild(coords)
    _polygon.addChild(data)
    _polygon.addChild(face)

    i = 0
    for vr in vertices:
        data.point.set1Value(i, vr[0], vr[1], vr[2])
    i += 1
    polygons = [
        0, 1, 2, 3, -1
    ]  # -1 means that the n-gon is terminated and a new one can be created with the next points

    i = 0
    for p in polygons:
        face.coordIndex.set1Value(i, p)
    i += 1
    return _polygon
Beispiel #19
0
    def attach(self,vobj):

        self.Object = vobj.Object
        self.clip = None
        from pivy import coin
        self.sep = coin.SoGroup()
        self.mat = coin.SoMaterial()
        self.sep.addChild(self.mat)
        self.dst = coin.SoDrawStyle()
        self.sep.addChild(self.dst)
        self.lco = coin.SoCoordinate3()
        self.sep.addChild(self.lco)
        lin = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
        lin.coordIndex.setValues([0,1,-1,2,3,-1,4,5,-1])
        self.sep.addChild(lin)
        self.bbox = coin.SoSwitch()
        self.bbox.whichChild = -1
        bboxsep = coin.SoSeparator()
        self.bbox.addChild(bboxsep)
        drawstyle = coin.SoDrawStyle()
        drawstyle.style = coin.SoDrawStyle.LINES
        drawstyle.lineWidth = 3
        drawstyle.linePattern = 0x0f0f  # 0xaa
        bboxsep.addChild(drawstyle)
        self.bbco = coin.SoCoordinate3()
        bboxsep.addChild(self.bbco)
        lin = coin.SoIndexedLineSet()
        lin.coordIndex.setValues([0,1,2,3,0,-1,4,5,6,7,4,-1,0,4,-1,1,5,-1,2,6,-1,3,7,-1])
        bboxsep.addChild(lin)
        self.sep.addChild(self.bbox)
        self.tra = coin.SoTransform()
        self.tra.rotation.setValue(FreeCAD.Rotation(0,0,90).Q)
        self.sep.addChild(self.tra)
        self.fon = coin.SoFont()
        self.sep.addChild(self.fon)
        self.txt = coin.SoAsciiText()
        self.txt.justification = coin.SoText2.LEFT
        self.txt.string.setValue("level")
        self.sep.addChild(self.txt)
        vobj.addDisplayMode(self.sep,"Default")
        self.onChanged(vobj,"ShapeColor")
        self.onChanged(vobj,"FontName")
        self.onChanged(vobj,"ShowLevel")
        self.onChanged(vobj,"FontSize")
        self.onChanged(vobj,"AutogroupBox")
        self.setProperties(vobj)
        return
Beispiel #20
0
    def attach(self, obj):
        material = coin.SoMaterial()
        material.diffuseColor = (1.0, 0.0, 0.0)
        material.emissiveColor = (1.0, 0.0, 0.0)
        drawStyle = coin.SoDrawStyle()
        drawStyle.pointSize.setValue(10)
        drawStyle.style = coin.SoDrawStyle.LINES
        wireframe = coin.SoGroup()
        shaded = coin.SoGroup()
        self.wireframe = wireframe
        self.shaded = shaded

        self.coords = coin.SoCoordinate3()
        self.coords.point.setValues(0, 2, [FreeCAD.Vector(0, 0, 0), FreeCAD.Vector(1, 0, 0)])
        wireframe += self.coords
        wireframe += drawStyle
        wireframe += material
        shaded += self.coords
        shaded += drawStyle
        shaded += material

        g = coin.SoGroup()
        sel1 = coin.SoType.fromName('SoFCSelection').createInstance()
        sel1.style = 'EMISSIVE_DIFFUSE'
        p1 = coin.SoType.fromName('SoIndexedPointSet').createInstance()
        p1.coordIndex.set1Value(0, 0)
        sel1 += p1
        g += sel1
        wireframe += g
        shaded += g

        g = coin.SoGroup()
        sel2 = coin.SoType.fromName('SoFCSelection').createInstance()
        sel2.style = 'EMISSIVE_DIFFUSE'
        p2 = coin.SoType.fromName('SoIndexedPointSet').createInstance()
        p2.coordIndex.set1Value(0, 1)
        sel2 += p2
        g += sel2
        wireframe += g
        shaded += g

        g = coin.SoGroup()
        sel3 = coin.SoType.fromName('SoFCSelection').createInstance()
        sel3.style = 'EMISSIVE_DIFFUSE'
        p3 = coin.SoType.fromName('SoIndexedLineSet').createInstance()
        p3.coordIndex.setValues(0, 2, [0, 1])
        sel3 += p3
        g += sel3
        wireframe += g
        shaded += g

        obj.addDisplayMode(wireframe, 'Wireframe')
        obj.addDisplayMode(shaded, 'Shaded')

        self.sel1 = sel1
        self.sel2 = sel2
        self.sel3 = sel3
        self.constructed = True
        self.updateData(obj.Object, 'p2')
Beispiel #21
0
    def attach(self, vobj):
        """Respond to created/restored object event (callback).

        Args:
            vobj -- Related ViewProviderDocumentObject
        """
        # pylint: disable=attribute-defined-outside-init
        self.fpo = vobj.Object

        # Here we create a coin representation
        self.coin = SimpleNamespace()
        scene = Gui.ActiveDocument.ActiveView.getSceneGraph()

        size = 5
        height = 10

        self.coin.geometry = coin.SoSwitch()
        self.coin.node = coin.SoSeparator()
        self.coin.transform = coin.SoTransform()
        self.coin.node.addChild(self.coin.transform)
        self.coin.material = coin.SoMaterial()
        self.coin.node.addChild(self.coin.material)
        self.coin.drawstyle = coin.SoDrawStyle()
        self.coin.drawstyle.style = coin.SoDrawStyle.LINES
        self.coin.drawstyle.lineWidth = 1
        self.coin.drawstyle.linePattern = 0xaaaa
        self.coin.node.addChild(self.coin.drawstyle)
        self.coin.coords = coin.SoCoordinate3()
        self.coin.coords.point.setValues(
            0, 15,
            [(-size * 2, +size, 0),          # Front rectangle
             (+size * 2, +size, 0),          # Front rectangle
             (+size * 2, -size, 0),          # Front rectangle
             (-size * 2, -size, 0),          # Front rectangle
             (-size * 2, +size, 0),          # Front rectangle
             (-size * 2, +size, 0),          # Left triangle
             (0, 0, height * 2),             # Left triangle
             (-size * 2, -size, 0),          # Left triangle
             (+size * 2, +size, 0),          # Right triangle
             (0, 0, height * 2),             # Right triangle
             (+size * 2, -size, 0),          # Right triangle
             (-size * 1.8, 1.2 * +size, 0),  # Up triangle (arrow)
             (0, 1.4 * +size, 0),            # Up triangle (arrow)
             (+size * 1.8, 1.2 * +size, 0),  # Up triangle (arrow)
             (-size * 1.8, 1.2 * +size, 0)]  # Up triangle (arrow)
        )
        self.coin.node.addChild(self.coin.coords)
        self.coin.lineset = coin.SoLineSet()
        self.coin.lineset.numVertices.setValues(0, 4, [5, 3, 3, 4])
        self.coin.node.addChild(self.coin.lineset)

        self.coin.geometry.addChild(self.coin.node)
        self.coin.geometry.whichChild.setValue(coin.SO_SWITCH_ALL)
        scene.addChild(self.coin.geometry)  # Insert back
        vobj.addDisplayMode(self.coin.geometry, "Shaded")

        # Update coin elements with actual object properties
        self._update_placement(self.fpo)
Beispiel #22
0
    def attach(self, obj):
        self.wireframe = coin.SoGroup()
        self.shaded = coin.SoSeparator()
        self.drawStyle = coin.SoDrawStyle()
        self.drawStyle.pointSize.setValue(10)
        self.drawStyle.style = coin.SoDrawStyle.LINES
        self.pointMaterial = coin.SoMaterial()
        self.pointMaterial.diffuseColor = (1.0, 0.0, 0.0)
        self.shaded += self.drawStyle
        self.shaded += self.pointMaterial
        self.wireframe += self.drawStyle
        self.wireframe += self.pointMaterial

        vertex_data = obj.Object.getPropertyByName('Points')
        n = obj.Object.getPropertyByName('NetWidth')
        m = obj.Object.getPropertyByName('NetLength')
        coord = coin.SoCoordinate3()
        coord.point.setValues(0, len(vertex_data), vertex_data)

        for ii in range(n):
            for jj in range(m):
                sep = coin.SoSeparator()
                sep += self.pointMaterial
                p = vertex_data[ii * m + jj]
                co = coin.SoCoordinate3()
                co.point.setValue(p[0], p[1], p[2])
                sep += co
                s = coin.SoType.fromName('SoPointSet').createInstance()
                s.numPoints.setValue(1)
                sep += s
                self.shaded += sep

        stations = coin.SoSeparator()
        stations += coord
        for ii in range(n):
            sep = coin.SoSeparator()
            indices = [ii + jj * n for jj in range(m)]
            lineSet = coin.SoType.fromName('SoBrepEdgeSet').createInstance()
            lineSet.coordIndex.setValues(0, len(indices), indices)
            sep += lineSet
            stations += sep

        self.shaded += stations
        self.wireframe += stations

        lines = coin.SoSeparator()
        lines += coord
        for jj in range(m):
            indices = [ii + jj * n for ii in range(n)]
            lineSet = coin.SoType.fromName('SoBrepEdgeSet').createInstance()
            lineSet.coordIndex.setValues(0, len(indices), indices)
            lines += lineSet

        self.shaded += lines
        self.wireframe += lines

        obj.addDisplayMode(self.wireframe, 'Wireframe')
        obj.addDisplayMode(self.shaded, 'Shaded')
Beispiel #23
0
def makeWindRose(epwfile,scale=1,sectors=24):

    """makeWindRose(site,sectors):
    returns a wind rose diagram as a pivy node"""

    try:
        import ladybug
        from ladybug import epw
    except Exception:
        FreeCAD.Console.PrintError("The ladybug module was not found. Unable to generate solar diagrams\n")
        return None
    if not epwfile:
        FreeCAD.Console.PrintWarning("No EPW file, unable to generate wind rose.\n")
        return None
    epw_data = ladybug.epw.EPW(epwfile)
    baseangle = 360/sectors
    sectorangles = [i * baseangle for i in range(sectors)] # the divider angles between each sector
    basebissect = baseangle/2
    angles = [basebissect] # build a list of central direction for each sector
    for i in range(1,sectors):
        angles.append(angles[-1]+baseangle)
    windsbysector = [0 for i in range(sectors)] # prepare a holder for values for each sector
    for hour in epw_data.wind_direction:
        sector = min(angles, key=lambda x:abs(x-hour)) # find the closest sector angle
        sectorindex = angles.index(sector)
        windsbysector[sectorindex] = windsbysector[sectorindex] + 1
    maxwind = max(windsbysector)
    windsbysector = [wind/maxwind for wind in windsbysector] # normalize
    vectors = [] # create 3D vectors
    dividers = []
    for i in range(sectors):
        angle = math.radians(90 + angles[i])
        x = math.cos(angle) * windsbysector[i] * scale
        y = math.sin(angle) * windsbysector[i] * scale
        vectors.append(FreeCAD.Vector(x,y,0))
        secangle = math.radians(90 + sectorangles[i])
        x = math.cos(secangle) * scale
        y = math.sin(secangle) * scale
        dividers.append(FreeCAD.Vector(x,y,0))
    vectors.append(vectors[0])

    # build coin node
    import Part
    from pivy import coin
    masternode = coin.SoSeparator()
    for r in (0.25,0.5,0.75,1.0):
        c = Part.makeCircle(r * scale)
        masternode.addChild(toNode(c))
    for divider in dividers:
        l = Part.makeLine(FreeCAD.Vector(),divider)
        masternode.addChild(toNode(l))
    ds = coin.SoDrawStyle()
    ds.lineWidth = 2.0
    masternode.addChild(ds)
    d = Part.makePolygon(vectors)
    masternode.addChild(toNode(d))
    return masternode
Beispiel #24
0
 def attach(self, vobj):
     '''Setup the scene sub-graph of the view provider'''
     from pivy import coin
     self.Object = vobj.Object
     self.color = coin.SoBaseColor()
     if hasattr(vobj, "LineColor"):
         self.color.rgb.setValue(vobj.LineColor[0], vobj.LineColor[1],
                                 vobj.LineColor[2])
     self.font = coin.SoFont()
     self.font3d = coin.SoFont()
     self.text = coin.SoAsciiText()
     self.text3d = coin.SoText2()
     self.text.string = "d"  # some versions of coin crash if string is not set
     self.text3d.string = "d"
     self.text.justification = self.text3d.justification = coin.SoAsciiText.CENTER
     self.textpos = coin.SoTransform()
     label = coin.SoSeparator()
     label.addChild(self.textpos)
     label.addChild(self.color)
     label.addChild(self.font)
     label.addChild(self.text)
     label3d = coin.SoSeparator()
     label3d.addChild(self.textpos)
     label3d.addChild(self.color)
     label3d.addChild(self.font3d)
     label3d.addChild(self.text3d)
     self.coord1 = coin.SoCoordinate3()
     self.trans1 = coin.SoTransform()
     self.coord2 = coin.SoCoordinate3()
     self.trans2 = coin.SoTransform()
     self.marks = coin.SoSeparator()
     self.drawstyle = coin.SoDrawStyle()
     self.coords = coin.SoCoordinate3()
     self.arc = coin.SoType.fromName("SoBrepEdgeSet").createInstance()
     self.node = coin.SoGroup()
     self.node.addChild(self.color)
     self.node.addChild(self.drawstyle)
     self.node.addChild(self.coords)
     self.node.addChild(self.arc)
     self.node.addChild(self.marks)
     self.node.addChild(label)
     self.node3d = coin.SoGroup()
     self.node3d.addChild(self.color)
     self.node3d.addChild(self.drawstyle)
     self.node3d.addChild(self.coords)
     self.node3d.addChild(self.arc)
     self.node3d.addChild(self.marks)
     self.node3d.addChild(label3d)
     vobj.addDisplayMode(self.node, "2D")
     vobj.addDisplayMode(self.node3d, "3D")
     self.updateData(vobj.Object, None)
     self.onChanged(vobj, "FontSize")
     self.onChanged(vobj, "FontName")
     self.onChanged(vobj, "ArrowType")
     self.onChanged(vobj, "LineColor")
     # backwards compatibility
     self.ScaleMultiplier = 1.00
Beispiel #25
0
    def makeBubbles(self):
        import Part

        def getNode():
            # make sure we already have the complete node built
            r = self.ViewObject.RootNode
            if r.getChildren().getLength() > 2:
                if r.getChild(2).getChildren().getLength() > 0:
                    if r.getChild(2).getChild(0).getChildren().getLength() > 0:
                        return self.ViewObject.RootNode.getChild(2).getChild(
                            0).getChild(0)
            return None

        rn = getNode()
        if rn:
            if self.bubbles:
                rn.removeChild(self.bubbles)
                self.bubbles = None
            self.bubbles = coin.SoSeparator()
            isep = coin.SoSeparator()
            self.bubblestyle = coin.SoDrawStyle()
            self.bubblestyle.linePattern = 0xffff
            self.bubbles.addChild(self.bubblestyle)
            for i in range(len(self.ViewObject.Object.Distances)):
                invpl = self.ViewObject.Object.Placement.inverse()
                verts = self.ViewObject.Object.Shape.Edges[i].Vertexes
                p1 = invpl.multVec(verts[0].Point)
                p2 = invpl.multVec(verts[1].Point)
                dv = p2.sub(p1)
                dv.normalize()
                rad = self.ViewObject.BubbleSize
                center = p2.add(dv.scale(rad, rad, rad))
                ts = Part.makeCircle(rad, center).writeInventor()
                cin = coin.SoInput()
                cin.setBuffer(ts)
                cob = coin.SoDB.readAll(cin)
                co = cob.getChild(1).getChild(0).getChild(2)
                li = cob.getChild(1).getChild(0).getChild(3)
                self.bubbles.addChild(co)
                self.bubbles.addChild(li)
                st = coin.SoSeparator()
                tr = coin.SoTransform()
                tr.translation.setValue(
                    (center.x, center.y - rad / 4, center.z))
                fo = coin.SoFont()
                fo.name = "Arial,Sans"
                fo.size = rad * 100
                tx = coin.SoText2()
                tx.justification = coin.SoText2.CENTER
                tx.string = self.getNumber(i)
                st.addChild(tr)
                st.addChild(fo)
                st.addChild(tx)
                isep.addChild(st)
            self.bubbles.addChild(isep)
            rn.addChild(self.bubbles)
Beispiel #26
0
 def attach(self, vobj):
     from pivy import coin
     self.centerlinegroup = coin.SoSeparator()
     self.centerlinegroup.setName("Centerline")
     self.centerlinecolor = coin.SoBaseColor()
     self.centerlinestyle = coin.SoDrawStyle()
     self.centerlinegroup.addChild(self.centerlinecolor)
     self.centerlinegroup.addChild(self.centerlinestyle)
     vobj.addDisplayMode(self.centerlinegroup, "Centerline")
     ArchComponent.ViewProviderComponent.attach(self, vobj)
 def __init__(self):
     self.trans = coin.SoTransform()
     w = coin.SoDrawStyle()
     w.style = coin.SoDrawStyle.LINES
     cube = coin.SoCube()
     self.array = coin.SoArray()
     self.array.addChild(cube)
     Tracker.__init__(
         self, children=[self.trans, w, self.array], name="arrayBoxTracker"
     )
 def __init__(self, points, color='black', width=1):
     self.object = coin.SoSeparator()
     self.ls = coin.SoLineSet()
     self.data = coin.SoCoordinate3()
     self.color = coin.SoMaterial()
     self.drawstyle = coin.SoDrawStyle()
     self.points = list(map(vector3D, points))
     self.color.diffuseColor = COLORS[color]
     self.drawstyle.lineWidth = width
     self.update()
     self.object += [self.color, self.drawstyle, self.data, self.ls]
Beispiel #29
0
 def __init__(self, points, width=1):
     self.object = coin.SoSeparator()
     self.ls = coin.SoLineSet()
     self.data = coin.SoCoordinate3()
     self.color = coin.SoMaterial()
     self.drawstyle = coin.SoDrawStyle()
     self.points = points
     self.color.diffuseColor = (1., 1., 1.)
     self.drawstyle.lineWidth = width
     self.update()
     self.object += self.color, self.drawstyle, self.data, self.ls
Beispiel #30
0
    def showStatisticsLine(self, docName , shapeName , pts , color):
        import FreeCADGui
        from pivy import coin
        
        sg = FreeCADGui.getDocument(docName).ActiveView.getSceneGraph()
        lines = coin.SoSeparator()
        self.__setRootNode(docName, sg, lines)
        
        drawStyle = coin.SoDrawStyle()
        drawStyle.style = coin.SoDrawStyle.LINES
        drawStyle.lineWidth = 2
#        drawStyle.pointSize = 3
        lines.addChild(drawStyle)
        
#        norm = coin.SoNormal()
#        norm.vector.setValue(0,0,1)
#        lines.addChild(norm)
        
        # set color for block
        matColors = coin.SoMaterial()
        col = (color[0],color[1],color[2])
#        matColors.ambientColor.setValue(color[0],color[1],color[2])
#        matColors.diffuseColor.setValue(color[0],color[1],color[2])
#        matColors.specularColor.setValue(color[0],color[1],color[2])
        matColors.diffuseColor.setValues(0,len(pts),[col]*len(pts))
        lines.addChild(matColors)

        tmpMatBind = coin.SoMaterialBinding()
        tmpMatBind.value = coin.SoMaterialBinding.PER_PART
        lines.addChild(tmpMatBind)
#        lineColor = coin.SoBaseColor()
#        lineColor.rgb = (color[0],color[1],color[2])
#        lines.addChild(lineColor)

        # point
#        tmpPts = []
#        for i in range(len(pts)-1):
#            tmpPts.append(pts[i])
#            tmpPts.append(pts[i+1])
        data = coin.SoCoordinate3()
#        data.point.setValues(0 , len(tmpPts),tmpPts)
        data.point.setValues(0 , len(pts),pts)
        lines.addChild(data)
        
        lineset=coin.SoLineSet()
        lineset.numVertices.setValues(0,1, [len(pts)] )
#        lineset = coin.SoIndexedLineSet()
#        nums = range(len(pts))
#        nums.append(-1)
#        lineset.coordIndex.setValues(0,len(nums), nums)
        lines.addChild(lineset)
        
        self.__setRootNode(docName, sg , lines)