Affichage des résultats 1 à 16 sur 16

Discussion: Python - Doc Utilitaires

  1. #1
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298

    Python - Doc Utilitaires

    Salut,

    Je vous propose une classe Utilitaire Python concoctée au fur et à mesure du temps, vous y trouverez des fonctions de modélisation en tout genre, des calculs informations sur un objet polygonal, des conversion de sélection...

    Certaines utilisent les SendModelingCommand, d'autres non (l'idée est à terme de ne plus avoir à se servir des commandes).


    Certaines de ces fonctions sont assez précieuses, d'autres que j'utilise tout le temps, j'espère que ça en aidera à développer de nouveaux outils !


    N'hésitez pas si vous avez des remarques, des suggestions, du café, il manque encore la fonction de Biseautage (elle déconne un peu).


    Sommaire

    Calculs sur un objet

    CalculeNormalesPolys
    CalculeNormalesPoints
    CalculeNormalesPointsPolys
    CalculeCentrePolys
    CalculeDecentreBruitPolys
    CalculeNombreAretesPolys
    CalculeAirePolys
    CalculeAirePolysFacteur
    CalculePerimetrePolys
    CalculeOrthocentreTriangles
    CalculeNbPolysParPoint
    CalculePointsBordureListe
    CalculePointsBordureMarquage
    CalculePointsBordureSelectMarquage
    CalculeAretes
    DictionnaireAretes
    CalculeAretesBordure
    CalculeAretesBordureAvecPolys
    CalculePolysBordureMarquage
    CalculePointPolysTries
    CalculeLiaisonPoints
    CalculeGroupesParPoly
    BruitPoints

    Calculs géométriques

    VolumeTetraedre
    AirePolygone
    PerimetrePolygone
    OrthocentreTriangle

    Modification d'un objet

    BruiteObjet
    LissageCatmullClark
    RecopieObjet
    Optimiser
    AlignerNormales
    InverserNormales
    Trianguler
    Quadranguler
    Subdiviser
    FermerTrous
    BiseauterCommande
    BiseauterC4D
    Biseauter
    ExtruderC4D
    Extruder
    ReductionDePolys
    SupprimerPolygones

    Opérations sur les polygones

    AreteOpposee
    AreteAdjacente
    ListeAretesPolygone
    ListeAretesPolygoneSensABCD

    Opérations sur les matrices

    TransposeMatrice

    Opérations sur les vecteurs

    RefleteVecteur
    IntersectionSegments2DBool
    IntersectionSegments2DVector
    IntersectionDroites2DBool
    IntersectionDroites2DVector

    Sélections

    BaseSelectAretesToutes
    BaseSelectPolysDepuisAretes
    BaseSelectPolysTous
    SelectionnePointsTous
    SelectionnePointsPolysPoints
    SelectionnePolysTous
    SelectionnePolysInverse
    SelectionnePolysAucun
    SelectionneAretesToutes
    SelectionneAretesInverse
    SelectionneAretesAucune
    SelectionneAretesContour
    MarquagePointsDepuisAretes
    AffichePolysTous
    AffichePointsTous
    AfficheAretesToutes

    Débug

    DebugVecteur
    DebugTexte


    Vous pouvez retrouver ou télécharger la classe ici : http://code.vonc.fr/?a=100
    Dernière modification par César Vonc ; 08/10/2017 à 12h49.

  2. #2
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Calculs sur un objet


    CalculeNormalesPolys




    Code PHP:
        def CalculeNormalesPolys(obj) :
        
            
    """
                Calcule les normales des polys de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de Vector) - Liste des normales
            """
            
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
    nbPolys obj.GetPolygonCount()
            
            
    norPolys = [c4d.Vector()] * nbPolys
            nor 
    c4d.Vector()
            
            for 
    ipoly in enumerate(polys) :
                
    nor = (pts[poly.a] - pts[poly.c]).Cross(pts[poly.b] - pts[poly.d])
                
    nor.Normalize()
                
    norPolys[i] = nor
            
            
    return norPolys 

    CalculeNormalesPoints




    Code PHP:
        def CalculeNormalesPoints(objbsPolys None) :
        
            
    """
                Calcule les normales des points de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bsPolys (BaseSelect) - Sélection de polygones pour limiter le calcul des normales des points
                
                Renvoie :
                    (liste de Vector) - Liste des normales
            """
            
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
    nbPoints obj.GetPointCount()
            
            
    norPts = [c4d.Vector()] * nbPoints
            
            
    if bsPolys is None :
            
                for 
    ipoly in enumerate(polys) :
                    
                    
    normale = (pts[poly.a] - pts[poly.c]).Cross(pts[poly.b] - pts[poly.d])
                    
    normale.Normalize()
                    
                    
    norPts[poly.a] += normale
                    norPts
    [poly.b] += normale
                    norPts
    [poly.c] += normale
                    
    if (poly.!= poly.d) : norPts[poly.d] += normale
            
            
    else :
            
                
    nbPolys obj.GetPolygonCount()
                
    bsTous bsPolys.GetAll(nbPolys)
                
                for 
    isel in enumerate(bsTous) :
                    
                    if 
    not sel : continue
                    
                    
    poly polys[i]
                    
                    
    normale = (pts[poly.a] - pts[poly.c]).Cross(pts[poly.b] - pts[poly.d])
                    
    normale.Normalize()
                    
                    
    norPts[poly.a] += normale
                    norPts
    [poly.b] += normale
                    norPts
    [poly.c] += normale
                    
    if (poly.!= poly.d) : norPts[poly.d] += normale
                
            
            
    for i in xrange(nbPoints) :
                
    norPts[i].Normalize()
            
            return 
    norPts 

    CalculeNormalesPointsPolys




    Code PHP:
        def CalculeNormalesPointsPolys(objbsPolys None) :
        
            
    """
                Calcule les normales des points et des polys de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bsPolys (BaseSelect) - Sélection de polygones pour limiter le calcul des normales
                
                Renvoie :
                    (liste de Vector) - Liste des normales des points
                    (liste de Vector) - Liste des normales des polys
            """
            
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
    nbPoints obj.GetPointCount()
            
    nbPolys obj.GetPolygonCount()
            
            
    norPts = [c4d.Vector()] * nbPoints
            norPolys 
    = [c4d.Vector()] * nbPolys
            
            
    if bsPolys is None :
            
                for 
    ipoly in enumerate(polys) :
                    
                    
    normale = (pts[poly.a] - pts[poly.c]).Cross(pts[poly.b] - pts[poly.d])
                    
    normale.Normalize()
                    
                    
    norPolys[i] = normale
                    
                    norPts
    [poly.a] += normale
                    norPts
    [poly.b] += normale
                    norPts
    [poly.c] += normale
                    
    if (poly.!= poly.d) : norPts[poly.d] += normale
            
            
    else :
            
                
    nbPolys obj.GetPolygonCount()
                
    bsTous bsPolys.GetAll(nbPolys)
                
                for 
    isel in enumerate(bsTous) :
                    
                    if 
    not sel : continue
                    
                    
    poly polys[i]
                    
                    
    normale = (pts[poly.a] - pts[poly.c]).Cross(pts[poly.b] - pts[poly.d])
                    
    normale.Normalize()
                    
                    
    norPolys[i] = normale
                    
                    norPts
    [poly.a] += normale
                    norPts
    [poly.b] += normale
                    norPts
    [poly.c] += normale
                    
    if (poly.!= poly.d) : norPts[poly.d] += normale
                
            
            
    for i in xrange(nbPoints) :
                
    norPts[i].Normalize()
            
            return 
    norPtsnorPolys 

    CalculeCentrePolys




    Code PHP:
        def CalculeCentrePolys(obj) :
            
            
    """
                Calcule le centre des polys de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de Vector) - Liste des positions
            """
            
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
    nbPolys obj.GetPolygonCount()
            
            
    centrePolys = [c4d.Vector()] * nbPolys
            centre 
    c4d.Vector()
            
            for 
    ipoly in enumerate(polys) :
                if 
    poly.!= poly.:
                    
    centre = (pts[poly.a] + pts[poly.b] + pts[poly.c] + pts[poly.d]) / 4.
                
    else :
                    
    centre = (pts[poly.a] + pts[poly.b] + pts[poly.c]) / 3.
                centrePolys
    [i] = centre
            
            
    return centrePolys 

    CalculeDecentreBruitPolys




    Code PHP:
        def CalculeDecentreBruitPolys(objintensite 1.0temps 0.0echelle 1.0) :
            
            
    """
                Calcule un point dans le polys de l'objet à partir d'un facteur de bruit.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    intensite (float) - Intensité du bruit
                    temps (float) - Temps
                    echelle (float) - Échelle du bruit
                
                Renvoie :
                    (liste de Vector) - Liste des positions
            """
            
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
    nbPolys obj.GetPolygonCount()
            
    bruit c4d.utils.noise.Noise
            mixVec 
    c4d.utils.MixVec
            
            centrePolys 
    = [c4d.Vector()] * nbPolys
            centre 
    c4d.Vector()
            
    decentre c4d.Vector()
            
    pos c4d.Vector()
            
            for 
    ipoly in enumerate(polys) :
                
                
    pts[poly.a]
                
    pts[poly.b]
                
    pts[poly.c]
                
    pts[poly.d]
                
                if 
    poly.!= poly.:
                    
                    
    centre = (d) / 4.
                    pos 
    centre echelle
                    
                    n 
    bruit(postemps)
                    
    bruit(pos 9999.temps)
                    
                    
    decentre * (.5) + * ((1. n) * .5) + * (.5) + * ((1. m) * .5)
                    
    decentre mixVec(centredecentreintensite)
                    
                else :
                
                    
    centre = (c) / 3.
                    pos 
    centre echelle
                    
                    n 
    bruit(postemps)
                    
    bruit(pos 9999.temps)
                    
                    
    = (b) * .5
                    
                    decentre 
    * (.5) + * ((1. n) * .5) + * (.5) + * ((1. m) * .5)
                    
    decentre mixVec(centredecentreintensite)
                    
                    
                
    centrePolys[i] = decentre
            
            
    return centrePolys 

    CalculeNombreAretesPolys




    Code PHP:
        def CalculeNombreAretesPolys(obj) :
            
            
    """
                Calcule le nombre d'arête de chaque polys.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de int) - Liste d'entiers
            """
            
            
    polys obj.GetAllPolygons()
            
    nbPolys obj.GetPolygonCount()
            
    nbAretesPolys = [0] * nbPolys
            
            
    for ipol in enumerate(polys) :
                
                
    nbAretesPolys[i] = if pol.== pol.else 4
            
            
    return nbAretesPolys 

    CalculeAirePolys




    Code PHP:
        def CalculeAirePolys(obj) :
            
            
    """
                Calcule l'aire de tous les polys.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de float) - Liste des aires
            """
            
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
    nbPolys obj.GetPolygonCount()
            
    aires = [0.] * nbPolys
            AirePolygone 
    VoncUtils.AirePolygone
            
            
    for ipol in enumerate(polys) :
                
                
    aires[i] = AirePolygone(polpts)
            
            return 
    aires 

    CalculeAirePolysFacteur




    Code PHP:
        def CalculeAirePolysFacteur(obj) :
            
            
    """
                Calcule un facteur de taille de 0 à 1 pour chaque poly par rapport à leur aire.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de float) - Liste de flottants de 0.0 à 1.0
            """
            
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
    nbPolys obj.GetPolygonCount()
            
    aires = [0.] * nbPolys
            mini 
    0.
            maxi 
    0.
            AirePolygone 
    VoncUtils.AirePolygone
            sqrt 
    math.sqrt
            
            
    for ipol in enumerate(polys) :
                
                
    aire sqrt(AirePolygone(polpts))
                
    aires[i] = aire
            
                
    if == :
                    
    mini aire
                    maxi 
    aire
                
    else :
                    if 
    aire mini mini aire
                    
    if aire maxi maxi aire
            
            diff 
    maxi mini
            
    if abs(diff) <= 0.000001 : return [1.] * nbPolys
            
            
    for iaire in enumerate(aires) :
                
                
    aires[i] = (aire mini) / diff
                
            
    return aires 

    CalculePerimetrePolys




    Code PHP:
        def CalculePerimetrePolys(obj) :
            
            
    """
                Calcule le périmètre de tous les polys.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de float) - Liste des périmètres
            """
            
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
    nbPolys obj.GetPolygonCount()
            
    perims = [0.] * nbPolys
            PerimetrePolygone 
    VoncUtils.PerimetrePolygone
            
            
    for ipol in enumerate(polys) :
                
                
    perims[i] = PerimetrePolygone(polpts)
            
            return 
    perims 

    CalculeOrthocentreTriangles




    Code PHP:
        def CalculeOrthocentreTriangles(obj) :
            
            
    """
                Calcule l'orthocentre des triangles de l'objet, à supposer que tous les polys sont des triangles.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de Vector) - Liste des positions
            """
            
            
    nbTriangles obj.GetPolygonCount()
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
            
    orthoPolys = [c4d.Vector()] * nbTriangles
            
            
    for ipoly in enumerate(polys) :
                
                
    pts[poly.a]
                
    pts[poly.b]
                
    pts[poly.c]
                
                
    orthoPolys[i] = VoncUtils.OrthocentreTriangle(abc)
            
            return 
    orthoPolys 

    CalculeNbPolysParPoint




    Code PHP:
        def CalculeNbPolysParPoint(objbsPolys None) :
            
            
    """
                Calcule le nombre de polygones autour de chaque point.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bsPolys (BaseSelect) - Sélection de polygones pour limiter le calcul
                
                Renvoie :
                    (liste de int) - Liste d'entiers
            """
            
            
    polys obj.GetAllPolygons()
            
    nbPts obj.GetPointCount()
            
            
    nbPolysParPts = [0] * nbPts
            
            
    if bsPolys is None :
            
                for 
    poly in polys :
                    
                    
    nbPolysParPts[poly.a] += 1
                    nbPolysParPts
    [poly.b] += 1
                    nbPolysParPts
    [poly.c] += 1
                    
                    
    if (poly.!= poly.d) : 
                        
    nbPolysParPts[poly.d] += 1


            
    else :
                
                
    nbPolys obj.GetPolygonCount()
                
    bsTous bsPolys.GetAll(nbPolys)
                
                for 
    isel in enumerate(bsTous) :
                    
                    if 
    not sel : continue
                    
                    
    poly polys[i]
                    
                    
    nbPolysParPts[poly.a] += 1
                    nbPolysParPts
    [poly.b] += 1
                    nbPolysParPts
    [poly.c] += 1
                    
                    
    if (poly.!= poly.d) : 
                        
    nbPolysParPts[poly.d] += 1
            
            
    return nbPolysParPts 

    CalculePointsBordureListe




    Code PHP:
        def CalculePointsBordureListe(objbsPolys None) :
            
            
    """
                Calcule la liste des points qui constituent la bordure de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bsPolys (BaseSelect) - Sélection de polygones pour limiter le calcul
                
                Renvoie :
                    (liste de int) - Liste d'indices des points de bordure
            """
            
            
    polys obj.GetAllPolygons()
            
            
    ptsBordure = []
            
            
    liaisonPts VoncUtils.CalculeLiaisonPoints(objbsPolys)
            
    nbPolysParPts VoncUtils.CalculeNbPolysParPoint(objbsPolys)
            
            for 
    inpol in enumerate(nbPolysParPts) :
                
                
    npt len(liaisonPts[i])
                if (
    npt != npol and npol != 0) :
                    
    ptsBordure.append(i)
            
            return 
    ptsBordure 

    CalculePointsBordureMarquage




    Code PHP:
        def CalculePointsBordureMarquage(objbsPolys None) :
            
            
    """
                Calcule le tableau de marquage des points qui constituent la bordure de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bsPolys (BaseSelect) - Sélection de polygones pour limiter le calcul
                
                Renvoie :
                    (liste de bool) - Liste de booléens marquants les points de bordure
            """
            
            
    polys obj.GetAllPolygons()
            
    nbPts obj.GetPointCount()
            
            
    ptsBordure = [False] * nbPts
            
            liaisonPts 
    VoncUtils.CalculeLiaisonPoints(objbsPolys)
            
    nbPolysParPts VoncUtils.CalculeNbPolysParPoint(objbsPolys)
            
            for 
    inpol in enumerate(nbPolysParPts) :
                
                
    npt len(liaisonPts[i])
                if (
    npt != npol) :
                    
    ptsBordure[i] = True
            
            
    return ptsBordure 

    CalculePointsBordureSelectMarquage




    Code PHP:
        def CalculePointsBordureSelectMarquage(objbsNone) :
            
            
    """
                Calcule le tableau de marquage des points qui constituent la bordure de la sélection du BaseSelect.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bs (BaseSelect) - Sélection de polygones pour limiter le calcul
                    n (Neighbor) - Neighbor initialisé avec le BaseSelect
                
                Renvoie :
                    (liste de bool) - Liste de booléens marquants les points de bordure
            """
            
            
    nbPolys obj.GetPolygonCount()
            
    nbPts obj.GetPointCount()
            
    polys obj.GetAllPolygons()
            
            if 
    n is None :
                
    c4d.utils.Neighbor()
                
    n.Init(objbs)
            
            
    ptsBords = [False] * nbPts
            
            
    for isel in enumerate(bs.GetAll(nbPolys)) :
            
                if 
    sel :
                
                    
    poly polys[i]
                
                    
    vois n.GetNeighbor(poly.apoly.bi)
                    if 
    vois == c4d.NOTOK :
                        
    ptsBords[poly.a] = True
                        ptsBords
    [poly.b] = True
                    
                    vois 
    n.GetNeighbor(poly.bpoly.ci)
                    if 
    vois == c4d.NOTOK :
                        
    ptsBords[poly.b] = True
                        ptsBords
    [poly.c] = True
                    
                    vois 
    n.GetNeighbor(poly.dpoly.ai)
                    if 
    vois == c4d.NOTOK :
                        
    ptsBords[poly.d] = True
                        ptsBords
    [poly.a] = True
                    
                    
    if poly.!= poly.:
                        
    vois n.GetNeighbor(poly.cpoly.di)
                        if 
    vois == c4d.NOTOK :
                            
    ptsBords[poly.c] = True
                            ptsBords
    [poly.d] = True
            
            
    return ptsBords 

    CalculeAretes




    Code PHP:
        def CalculeAretes(obj) :
            
            
    """
                Calcule la liste des arêtes de l'objet. Une arête est un couple de deux indices de points, le premier inférieur au second.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de tuple(int, int)) - Liste d'arêtes, une arête étant un tuple de deux ID de points, trié.
            """
            
            
    aretes = []
            
    aretesDico = {}
                
            
    polys obj.GetAllPolygons()
            
            for 
    pol in polys :
                
                
    areAB = (pol.apol.b)
                if (
    pol.pol.a) : areAB = (pol.bpol.a)
                
    aretesDico[areAB] = True
                
                areBC 
    = (pol.bpol.c)
                if (
    pol.pol.b) : areBC = (pol.cpol.b)
                
    aretesDico[areBC] = True
                
                
    if pol.== pol.:
                    
    areCA = (pol.cpol.a)
                    if (
    pol.pol.c) : areCA = (pol.apol.c)
                    
    aretesDico[areCA] = True
                    
                
    else :
                    
    areCD = (pol.cpol.d)
                    if (
    pol.pol.c) : areCD = (pol.dpol.c)
                    
    aretesDico[areCD] = True
                    
                    areDA 
    = (pol.dpol.a)
                    if (
    pol.pol.d) : areDA = (pol.apol.d)
                    
    aretesDico[areDA] = True
            
            aretes 
    aretesDico.keys()
            return 
    aretes 

    DictionnaireAretes




    Code PHP:
        def DictionnaireAretes(obj) :
            
            
    """
                Renvoie le dictionnaire des arêtes de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (dictionnaire de tuple(int, int)) - Dictionnaire avec les arêtes comme clef et None comme valeur, une arête étant un tuple de deux ID de points, trié.
            """
            
            
    aretesDico = {}
                
            
    polys obj.GetAllPolygons()
            
            for 
    pol in polys :
                
                
    areAB = (pol.apol.b)
                if (
    pol.pol.a) : areAB = (pol.bpol.a)
                
    aretesDico[areAB] = None
                
                areBC 
    = (pol.bpol.c)
                if (
    pol.pol.b) : areBC = (pol.cpol.b)
                
    aretesDico[areBC] = None
                
                
    if pol.== pol.:
                    
    areCA = (pol.cpol.a)
                    if (
    pol.pol.c) : areCA = (pol.apol.c)
                    
    aretesDico[areCA] = None
                    
                
    else :
                    
    areCD = (pol.cpol.d)
                    if (
    pol.pol.c) : areCD = (pol.dpol.c)
                    
    aretesDico[areCD] = None
                    
                    areDA 
    = (pol.dpol.a)
                    if (
    pol.pol.d) : areDA = (pol.apol.d)
                    
    aretesDico[areDA] = None
            
            
    return aretesDico 

    CalculeAretesBordure




    Code PHP:
        def CalculeAretesBordure(objNone) :
            
            
    """
                Calcule la liste des arêtes de bordure de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    n (Neighbor) - Neighbor initialisé
                
                Renvoie :
                    (liste de tuple(int, int)) - Liste d'arêtes de bordure, une arête étant un tuple de deux ID de points, trié.
            """
            
            
    aretes = []
            
            
    polys obj.GetAllPolygons()
            
            if 
    n is None :
                
    c4d.utils.Neighbor()
                
    n.Init(obj)
            
            for 
    ipol in enumerate(polys) :
                
                
    nab n.GetNeighbor(pol.apol.bi)
                
    nbc n.GetNeighbor(pol.bpol.ci)
                
    nda n.GetNeighbor(pol.dpol.ai)
                
                if 
    nab == c4d.NOTOK :
                    
    are = (pol.apol.b) if pol.pol.else (pol.bpol.a)
                    
    aretes.append(are)
                
                if 
    nbc == c4d.NOTOK :
                    
    are = (pol.bpol.c) if pol.pol.else (pol.cpol.b)
                    
    aretes.append(are)
                
                if 
    nda == c4d.NOTOK :
                    
    are = (pol.dpol.a) if pol.pol.else (pol.apol.d)
                    
    aretes.append(are)
                    
                if 
    pol.!= pol.:
                
                    
    ncd n.GetNeighbor(pol.cpol.di)
                    
                    if 
    ncd == c4d.NOTOK :
                        
    are = (pol.cpol.d) if pol.pol.else (pol.dpol.c)
                        
    aretes.append(are)
                    
            return 
    aretes 

    CalculeAretesBordureAvecPolys




    Code PHP:
        def CalculeAretesBordureAvecPolys(objNonebsPolys None) :
            
            
    """
                Calcule la liste des arêtes de bordure de l'objet, avec l'id du poly pour chaque arête.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    n (Neighbor) - Neighbor initialisé avec le BaseSelect
                    bsPolys (BaseSelect) - Sélection de polygones pour délimiter la zone
                
                Renvoie :
                    (liste de tuple(int, int, int)) - Liste d'arêtes avec ID du polygone, une arête étant un tuple de deux ID de points, trié.
            """
            
            
    aretes = []
            
            
    polys obj.GetAllPolygons()
            
    nbPolys obj.GetPolygonCount()
            
            if 
    n is None :
                
    c4d.utils.Neighbor()
                
    n.Init(objbsPolys)
            
            
    def calculeBord(npoliaretes) :
            
                
    nab n.GetNeighbor(pol.apol.bi)
                
    nbc n.GetNeighbor(pol.bpol.ci)
                
    nda n.GetNeighbor(pol.dpol.ai)
                
                if 
    nab == c4d.NOTOK :
                    
    are = (pol.apol.bi) if pol.pol.else (pol.bpol.ai)
                    
    aretes.append(are)
                
                if 
    nbc == c4d.NOTOK :
                    
    are = (pol.bpol.ci) if pol.pol.else (pol.cpol.bi)
                    
    aretes.append(are)
                
                if 
    nda == c4d.NOTOK :
                    
    are = (pol.dpol.ai) if pol.pol.else (pol.apol.di)
                    
    aretes.append(are)
                    
                if 
    pol.!= pol.:
                
                    
    ncd n.GetNeighbor(pol.cpol.di)
                        
                    if 
    ncd == c4d.NOTOK :
                        
    are = (pol.cpol.di) if pol.pol.else (pol.dpol.ci)
                        
    aretes.append(are)
            
            
            if 
    bsPolys is None :
                for 
    ipol in enumerate(polys) :
                    
    calculeBord(npoliaretes)
            
            else :
                
    bsTous bsPolys.GetAll(nbPolys)
                for 
    isel in enumerate(bsTous) :
                    if 
    sel calculeBord(npolys[i], iaretes)
            
            return 
    aretes 

    CalculePolysBordureMarquage




    Code PHP:
        def CalculePolysBordureMarquage(obj) :
            
            
    """
                Calcule le tableau de marquage des polys qui déterminent la bordure de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (liste de bool) - Liste de booléens marquants les polys qui constituent la bordure de l'objet.
            """
            
            
    polysBord = [False] * obj.GetPolygonCount()
            
            
    polys obj.GetAllPolygons()
            
    c4d.utils.Neighbor()
            
    n.Init(obj)
            
            for 
    ipol in enumerate(polys) :
                
                
    nab n.GetNeighbor(pol.apol.bi)
                
    nbc n.GetNeighbor(pol.bpol.ci)
                
    nda n.GetNeighbor(pol.dpol.ai)
                
                if 
    nab == c4d.NOTOK :
                    
    polysBord[i] = True
                
                
    if nbc == c4d.NOTOK :
                    
    polysBord[i] = True
                
                
    if nda == c4d.NOTOK :
                    
    polysBord[i] = True
                    
                
    if pol.!= pol.:
                
                    
    ncd n.GetNeighbor(pol.cpol.di)
                        
                    if 
    ncd == c4d.NOTOK :
                        
    polysBord[i] = True
                    
            
    return polysBord 

    CalculePointPolysTries




    Code PHP:
        def CalculePointPolysTries(objnei None) :
            
            
    """
                Calcule les polygones attachés à chaque point, triés par sens horaire.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    nei (Neighbor) - Neighbor initialisé
                
                Renvoie :
                    (liste de liste de int) - Liste des ID des polygones autour de chaque point, triés par sens horaire.
            """
            
            
    if nei is None :
                
    nei c4d.utils.Neighbor()
                
    nei.Init(obj)
            
            
    nbPts obj.GetPointCount()
            
    polys obj.GetAllPolygons()
            
    pts obj.GetAllPoints()
            
            
    pointsPolys = [None] * nbPts
            
            
    for i in xrange(nbPts) :
                
                
    polsDuPt nei.GetPointPolys(i)
                
                if 
    not polsDuPt :
                    
    pointsPolys[i] = []
                    continue
                
                
    nbVois len(polsDuPt)
                
    polsDuPtTrie = []
                
                
    pol polsDuPt[0]
                
    polDeb pol
                arete 
    None
                inverser 
    False
                autreAreteDebut 
    False
                
                k 
    0
                
    while nbVois :
                    
                    
    polsDuPtTrie.append(pol)
                    
                    
    poly polys[pol]
                    
                    
    # icentre est le point i, iexts sont les deux autres points du poly, situés après et avant icentre (par ordre abcd)
                    
    icentre poly.a
                    iexts 
    = (poly.bpoly.d# a, suivant : b, précédent : d (c = d pour triangle)
                    
    if poly.== :
                        
    icentre poly.b
                        iexts 
    = (poly.cpoly.a# b, suivant : c, précédent : a
                    
    elif poly.== :
                        
    icentre poly.c
                        
    if poly.!= poly.:
                            
    iexts = (poly.dpoly.b# (pour quadrangle) c, suivant : d, précédent : b
                        
    else :
                            
    iexts = (poly.apoly.b# (pour triangle) c, suivant : a, précédent : b
                    
    elif poly.== :
                        
    icentre poly.d
                        iexts 
    = (poly.apoly.c# (pour quadrangle exclusivement) b, suivant : a, précédent : c
                    
                    
    if == or autreAreteDebut :
                        
    # Pour le premier poly, prendre l'arête du point qui suit l'ordre abcd du poly (nécessite les normales alignées)
                        
    arete = (icentreiexts[0])
                        if 
    autreAreteDebut :
                            
    arete = (icentreiexts[1])
                        
                    else :
                        
    # Prendre une arête du poly qui ne soit pas celle précédemment choisie
                        
    arete = (icentreiexts[0]) if iexts[0] != arete[1] else (icentreiexts[1])
                    
                    
    premsec nei.GetEdgePolys(arete[0], arete[1])
                    
                    
    # Trouver le voisin qui ne soit pas égal au premier poly ni au poly précédemment ajouté
                    
    if prem != c4d.NOTOK or sec != c4d.NOTOK :
                        
                        if 
    prem != polDeb and prem != pol and prem != c4d.NOTOK :
                            
                            
    pol prem
                            
                        elif sec 
    != polDeb and sec != pol and sec != c4d.NOTOK :
                            
                            
    pol sec
                        
                        
    else :
                            if 
    == :
                                
    # Dans le cas du premier poly ajouté, si le sens choisi donne sur un bord, parcourir dans l'autre sens puis inverser le résultat et supprimer le doublon du premier poly.
                                
    pol pol
                                polsDuPtTrie
    .pop()
                                
    inverser True
                            
    else :
                                if 
    len(polsDuPtTrie) != nbVois :
                                    
    # S'il manque des polys, c'est qu'on a commencé par une arête d'un poly sans arête de bordure, et qu'on est tombé sur une bordure prématurément
                                    # Dans ce cas, partir dans l'autre sens à partir du poly de départ, mais avec l'autre arête.
                                    # Inverser le tableau actuel pour que l'ajout se fasse dans le bon ordre, puis réinverser le tout.
                                    
    polsDuPtTrie.reverse()
                                    
    _deb polsDuPtTrie.pop()
                                    
    inverser True
                                    autreAreteDebut 
    True
                                    pol 
    polDeb
                                    polDeb 
    _deb
                                
    else :
                                    break
                        
                    else :
                        break
                    
                    
    += 1
                
                
    if not inverser :
                    
    polsDuPtTrie.reverse()
                
                
    pointsPolys[i] = polsDuPtTrie
                
            
    return pointsPolys 

    CalculeLiaisonPoints




    Code PHP:
        def CalculeLiaisonPoints(objbsPolys None) :
            
            
    """
                Calcule la liste des points voisins de chaque point.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bsPolys (BaseSelect) - Sélection de polygones pour délimiter la zone
                
                Renvoie :
                    (liste de liste de int) - Liste des ID des points autour de chaque point.
            """
            
            
    nbPts obj.GetPointCount()
            
    polys obj.GetAllPolygons()
            
    liaisonPts = [None] * nbPts
            
            
    for i in xrange(nbPts) :
                
    liaisonPts[i] = set()
            
            if 
    bsPolys is None :
                for 
    poly in polys :
                    
                    
    liaisonPts[poly.a].add(poly.d)
                    
    liaisonPts[poly.a].add(poly.b)
                
                    
    liaisonPts[poly.b].add(poly.a)
                    
    liaisonPts[poly.b].add(poly.c)
                
                    if (
    poly.!= poly.d) :
                        
    # Quadrangle
                        
    liaisonPts[poly.c].add(poly.b)
                        
    liaisonPts[poly.c].add(poly.d)
                        
                        
    liaisonPts[poly.d].add(poly.c)
                        
    liaisonPts[poly.d].add(poly.a)
                        
                    else :
                        
    # Triangle
                        
    liaisonPts[poly.c].add(poly.b)
                        
    liaisonPts[poly.c].add(poly.a)
            
            else :
                
    nbPolys obj.GetPolygonCount()
                
    bsTous bsPolys.GetAll(nbPolys)
                
                for 
    isel in enumerate(bsTous) :
                    
                    if 
    not sel : continue
                    
    poly polys[i]
                    
                    
    liaisonPts[poly.a].add(poly.d)
                    
    liaisonPts[poly.a].add(poly.b)
                
                    
    liaisonPts[poly.b].add(poly.a)
                    
    liaisonPts[poly.b].add(poly.c)
                
                    if (
    poly.!= poly.d) :
                        
    # Quadrangle
                        
    liaisonPts[poly.c].add(poly.b)
                        
    liaisonPts[poly.c].add(poly.d)
                        
                        
    liaisonPts[poly.d].add(poly.c)
                        
    liaisonPts[poly.d].add(poly.a)
                        
                    else :
                        
    # Triangle
                        
    liaisonPts[poly.c].add(poly.b)
                        
    liaisonPts[poly.c].add(poly.a)
            
            
            for 
    i in xrange(nbPts) :
                
    liaisonPts[i] = tuple(liaisonPts[i])
            
            return 
    liaisonPts 

    CalculeGroupesParPoly




    Code PHP:
        def CalculeGroupesParPoly(obj):
        
            
    """
                Calcule pour chaque poly l'ID du groupe de polygones auquel il appartient
                
                Paramètres :
                    (PolygonObject) - Objet
                
                Renvoie :
                    (liste de int) - Liste d'ID de groupe pour chaque polygone
                    (int) - Nombre de groupes
            """
            
            
    if not obj : return NoneNone
            
            nbPolys 
    obj.GetPolygonCount()
            
    polys obj.GetAllPolygons()
            
            
    polysGroupe = [-1] * nbPolys
            nbGroupes 
    0
            
            n 
    c4d.utils.Neighbor()
            
    n.Init(obj)
            
            for 
    ig in enumerate(polysGroupe) :
                
                if 
    != -: continue
                
                
    polysATraiter = [i]
                
                while(
    polysATraiter) :
                
                    
    polysATraiterSuivant = []
                    
                    for 
    p in polysATraiter :
                        
                        
    polysGroupe[p] = nbGroupes
                        
                    
    for p in polysATraiter :
                        
                        
    poly polys[p]
                        
                        
    voisA n.GetNeighbor(poly.apoly.bp)
                        
    voisB n.GetNeighbor(poly.bpoly.cp)
                        
    voisD n.GetNeighbor(poly.dpoly.ap)
                        
    voisC c4d.NOTOK
                        
                        
    if poly.!= poly.:
                            
    voisC n.GetNeighbor(poly.cpoly.dp)
                        
                        if 
    voisA != c4d.NOTOK and polysGroupe[voisA] == -:
                            
    polysATraiterSuivant.append(voisA)
                        
                        if 
    voisB != c4d.NOTOK and polysGroupe[voisB] == -:
                            
    polysATraiterSuivant.append(voisB)
                        
                        if 
    voisC != c4d.NOTOK and polysGroupe[voisC] == -:
                            
    polysATraiterSuivant.append(voisC)
                        
                        if 
    voisD != c4d.NOTOK and polysGroupe[voisD] == -:
                            
    polysATraiterSuivant.append(voisD)
                    
                    
    polysATraiter = list(set(polysATraiterSuivant))
                
                
    nbGroupes += 1
            
            
    return polysGroupenbGroupes 

    BruitPoints




    Code PHP:
        def BruitPoints(objintensite 1.0temps 0.0echelle 1.0) :
            
            
    """
                Renvoie une valeur aléatoire pour chaque point de l'objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    intensite (float) - Intensité du bruit
                    temps (float) - Temps
                    echelle (float) - Échelle du bruit
                
                Renvoie :
                    (liste de float) - Liste de flottants, de 0.0 à 1.0
            """
            
            
    nbPts obj.GetPointCount()
            
    pts obj.GetAllPoints()
            
    bruit = [0.] * nbPts
            
            
    if nbPts == : return bruit
            
            noise 
    c4d.utils.noise.Noise
            mixVec 
    c4d.utils.MixVec
            
            
    for i in xrange(nbPts) :
                
                
    bruit[i] = noise(pts[i] * echelletemps) * intensite
            
            
    return bruit 
    Dernière modification par César Vonc ; 08/10/2017 à 13h44.

  3. #3
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Calculs géométriques


    VolumeTetraedre


    Code PHP:
        def VolumeTetraedre(p1p2p3) :
            
            
    """
                Calcule le volume d'un tétraèdre.
                
                Paramètres :
                    p1 (Vector) - Position du premier point
                    p2 (Vector) - Position du second point
                    p3 (Vector) - Position du troisième point
                
                Renvoie :
                    (float) - Volume
            """
            
            
    return p1.Dot(p2.Cross(p3)) / 6.0 

    AirePolygone


    Code PHP:
        def AirePolygone(polpts) :
            
            
    """
                Calcule l'aire d'un polygone.
                
                Paramètres :
                    pol (CPolygon) - Polygone
                    pts (liste de Vector) - Points de l'objet
                
                Renvoie :
                    (float) - Aire
            """
            
            
    pts[pol.a]
            
    pts[pol.b]
            
    pts[pol.c]
            
            if 
    pol.IsTriangle() :
            
                return (
    b).Cross(c).GetLength() * 0.5
            
            d 
    pts[pol.d]
            
            
    ac c
            
    return ((b).Cross(ac).GetLength() + (ac).Cross(d).GetLength()) * 0.5 

    PerimetrePolygone


    Code PHP:
        def PerimetrePolygone(polpts) :
            
            
    """
                Calcule le périmètre d'un polygone.
                
                Paramètres :
                    pol (CPolygon) - Polygone
                    pts (liste de Vector) - Points de l'objet
                
                Renvoie :
                    (float) - Périmètre
            """
            
            
    pts[pol.a]
            
    pts[pol.b]
            
    pts[pol.c]
            
            if 
    pol.IsTriangle() :
                
                return (
    b).GetLength() + (c).GetLength() + (a).GetLength()
            
            
    pts[pol.d]
            
            return (
    b).GetLength() + (c).GetLength() + (d).GetLength() + (a).GetLength() 

    OrthocentreTriangle


    Code PHP:
        def OrthocentreTriangle(abc) :
            
            
    """
                Calcule l'orthocentre d'un triangle 3D.
                
                Paramètres :
                    a (Vector) - Premier point
                    b (Vector) - Second point
                    c (Vector) - Troisième point
                
                Renvoie :
                    (Vector ou None) - Orthocentre
            """
            
            
    ab a
            bc 
    b
            cb 
    c
            abn 
    ab.GetNormalized()
            
    bcn bc.GetNormalized()
            
            
    mab abn.Dot(a) * abn a
            mbc 
    bcn.Dot(b) * bcn b
            
            n 
    = (c).Cross(cb)
            
            
    hab ab.Cross(n)
            
    hbc = (cb).Cross(n)
            
            
    c4d.utils.HPBToMatrix(c4d.utils.VectorToHPB(n))
            
    m.off b
            mi 
    = ~m
            
            hab 
    mi.Mul(hab)
            
    hbc mi.Mul(hbc)
            
            
    mab mi.Mul(mab)
            
    mbc mi.Mul(mbc)
            
            
    inter VoncUtils.IntersectionDroites2DVector(mabmab habmbcmbc hbc)
            
            if 
    inter is None :
                return 
    None
            
            inter 
    m.Mul(inter)
            
            return 
    inter 
    Dernière modification par César Vonc ; 08/10/2017 à 13h38.

  4. #4
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Modification d'un objet


    BruiteObjet




    Code PHP:
        def BruiteObjet(objintensite 1.0temps 0.0echelle 1.0) :
            
            
    """
                Déforme les points d'un objet le long de ses arêtes de façon aléatoire.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    intensite (float) - Intensité du bruit
                    temps (float) - Temps
                    echelle (float) - Échelle du bruit
            """
            
            
    nbPts obj.GetPointCount()
            
    pts obj.GetAllPoints()
            
    pts2 = [c4d.Vector()] * nbPts
            
            
    if nbPts == : return
            
            
    liaisonPts VoncUtils.CalculeLiaisonPoints(obj)
            
    bruit c4d.utils.noise.Noise
            mixVec 
    c4d.utils.MixVec
            
            
    for i in xrange(nbPts) :
                
                
    ptsVois liaisonPts[i# Points autour du point
                
    nbPtsVois len(ptsVois)
                
                
    pt pts[i]
                
                
    pt2 c4d.Vector()
                
                for 
    vois in ptsVois :
                    
                    
    bruit(pts[vois] * echelletemps) * 2. 1.
                    pt2 
    += mixVec(ptpts[vois], n)
                
                
    pt2 /= float(nbPtsVois)
                
                
    pts2[i] = mixVec(ptpt2intensite)
            
            
    obj.SetAllPoints(pts2)
            
    obj.Message(c4d.MSG_UPDATE

    LissageCatmullClark




    Code PHP:
        def LissageCatmullClark(objintensite 1.0influence Nonenei NonebsPolys None) :
            
            
    """
                Lisse les points de l'objet basé sur la méthode Catmull-Clark.
                
                Paramètres :
                    intensite (float) - Facteur d'intensité du lissage (0.0 à 1.0).
                    influence (liste de float) - Facteur d'intensité du lissage pour chaque point.
                    nei (Neihbor) - Neighbor initialisé avec le BaseSelect.
                    bsPolys (BaseSelect) - Sélection de polygones pour limiter l'effet.
            """
            
            
    if nei is None :
                
    nei c4d.utils.Neighbor()
                
    nei.Init(objbsPolys)
            
            
    nbPts obj.GetPointCount()
            
    pts obj.GetAllPoints()
            
            if 
    nbPts == : return
            
            
    ptsNouv = [c4d.Vector()] * nbPts
            
            liaisonPts 
    VoncUtils.CalculeLiaisonPoints(objbsPolys)
            
    centrePolys VoncUtils.CalculeCentrePolys(obj)
            
            
            for 
    i in xrange(nbPts) :
                
                
    polsVois nei.GetPointPolys(i# Polys autour du point
                
    nbPolsVois len(polsVois)
                
                
    ptsVois liaisonPts[i# Points liés au point i
                
    nbPtsVois len(ptsVois)
                
                if 
    not nbPolsVois or not nbPtsVois :
                    
    ptsNouv[i] = pts[i]
                    continue
                
                
    pmaBord = [] # Point de Milieu d'Arête de Bordure
                
    po pts[i# Point Original
                
    pos c4d.Vector() # Nouvelle position
                
                
    if nbPtsVois != nbPolsVois # Bordure
                    
                    
    if nbPtsVois != nbPolsVois # Point avec plus de 2 bordures
                        
                        
    pos po
                        
                    
    else :
                        
                        
    pmaMoy c4d.Vector()
                        
    nbBord 0
                        
                        
    for j in ptsVois :
                            
                            
    premsec nei.GetEdgePolys(ij)
                            
                            if 
    prem == c4d.NOTOK or sec == c4d.NOTOK :
                                
    pmaMoy += (po pts[j]) * .5
                                nbBord 
    += 1
                        
                        pmaMoy 
    /= float(nbBord)
                        
                        
    pos = (po pmaMoy) * .5
                      
                
    else :
                    
                    
    nbPolsVois float(nbPolsVois)
                    
    nbPtsVois float(nbPtsVois)
                    
                    
    # Moyenne des Point de Surface
                    
    psMoy c4d.Vector()
                    for 
    j in polsVois :
                        
    psMoy += centrePolys[j]
                    
    psMoy /= nbPolsVois
                    
                    
    # Moyenne des Points d'Arête
                    
    pmaMoy c4d.Vector()
                    for 
    j in ptsVois :
                        
    pmaMoy += (po pts[j]) * .5
                    pmaMoy 
    /= nbPtsVois
                    
                    
    # Catmull-Clark
                    
    pos psMoy + (2.0 pmaMoy) + ((nbPolsVois 3.0) * po);
                    
    pos /= nbPolsVois
                    
                
                ptsNouv
    [i] = pos
                
                
            
    for iptNouv in enumerate(ptsNouv) :
                
                if 
    influence :
                    
    pts[i] = ptNouv intensite influence[i] + (pts[i] * (1. intensite influence[i]))
                else :
                    
    pts[i] = ptNouv intensite + (pts[i] * (1. intensite))
            
            
            
    obj.SetAllPoints(pts)
            
    obj.Message(c4d.MSG_UPDATE

    RecopieObjet


    Code PHP:
        def RecopieObjet(srcdest) :
        
            
    """
                Recopie les données polygonales d'un objet vers un autre.
                
                Paramètres :
                    src (PolygonObject) - Objet source
                    dest (PolygonObject) - Objet de destination
                
                Renvoie :
                    (bool) - Booléen, succès ou non
            """
            
            
    nouvNbPts src.GetPointCount()
            
    nouvNbPolys src.GetPolygonCount()
            
    nouvPts src.GetAllPoints()
            
    nouvPolys src.GetAllPolygons()
            
            if 
    nouvNbPts == :
                return 
    False
            
            dest
    .ResizeObject(nouvNbPtsnouvNbPolys)
            
    dest.Message(c4d.MSG_UPDATE)
            
            
    dest.SetAllPoints(nouvPts)
            for 
    ip in enumerate(nouvPolys) :
                
    dest.SetPolygon(ip)
                
            
    dest.Message(c4d.MSG_UPDATE)
            return 
    True 

    Optimiser


    Code PHP:
        def Optimiser(objdocpolys Truepts Trueptsiso Truetolerance 0.01) :
            
            
    """
                Optimiser.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                    polys (bool) - Optimiser les polygones
                    pts (bool) - Optimiser les points
                    ptsiso (bool) - Optimiser les points isolés
                    tolerance (float) - Tolérance d'optimisation des points
            """
            
            
    params c4d.BaseContainer()
            
    params[c4d.MDATA_OPTIMIZE_TOLERANCE] = tolerance
            params
    [c4d.MDATA_OPTIMIZE_POINTS] = pts
            params
    [c4d.MDATA_OPTIMIZE_POLYGONS] = polys
            params
    [c4d.MDATA_OPTIMIZE_UNUSEDPOINTS] = ptsiso
            c4d
    .utils.SendModelingCommand(command=c4d.MCOMMAND_OPTIMIZE, list=[obj], bc=paramsdoc=doc

    AlignerNormales


    Code PHP:
        def AlignerNormales(objdoc) :
            
            
    """
                Aligner les normales.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                
                Renvoie :
                    (bool) - Succès ou non
            """
            
            
    return c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_ALIGNNORMALS, list=[obj], doc=doc

    InverserNormales


    Code PHP:
        def InverserNormales(objdoc) :
            
            
    """
                Inverser les normales.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                
                Renvoie :
                    (bool) - Succès ou non
            """
            
            
    return c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_REVERSENORMALS, list=[obj], doc=doc

    Trianguler


    Code PHP:
        def Trianguler(objdoc) :
            
            
    """
                Convertit les polygones en triangles.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                
                Renvoie :
                    (bool) - Succès ou non
            """
            
            
    return c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_TRIANGULATE, list=[obj], doc=doc

    Quadranguler


    Code PHP:
        def Quadranguler(objdoc) :
            
            
    """
                Convertit les triangles en quadrangles.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                
                Renvoie :
                    (bool) - Succès ou non
            """
            
            
    bc c4d.BaseContainer()
            
    bc[c4d.MDATA_UNTRIANGULATE_NGONS] = False
            bc
    [c4d.MDATA_UNTRIANGULATE_ANGLE_RAD] = .1 * (math.pi 180.)
            
    bc[c4d.MDATA_UNTRIANGULATE_ANGLE] = False
            
            
    return c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_UNTRIANGULATE, list=[obj], bc=bcdoc=doc

    Subdiviser




    Code PHP:
        def Subdiviser(objdociterations 1catmullClark TrueselectionActive Falsebs None) :
         
            
    """
                Subdivise les polygones d'un objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                    iterations (int) - Nombre d'itération de la subdivision
                    catmullClark (bool) - Active ou non la subdivision de type Catmull-Clark
                    selectionActive (bool) - Utilise ou non la sélection de polygone courante
                    bs (BaseSelect) - Sélection de polygones pour limiter la subdivision
                
                Renvoie :
                    (bool) - Succès ou non
            """
            
            
    bc c4d.BaseContainer()
            
    bc[c4d.MDATA_SUBDIVIDE_HYPER] = catmullClark
            bc
    [c4d.MDATA_SUBDIVIDE_ANGLE] = math.pi
            bc
    [c4d.MDATA_SUBDIVIDE_SUB] = iterations
            mode 
    c4d.MODELINGCOMMANDMODE_ALL
            
            
    if selectionActive :
                
    mode c4d.MODELINGCOMMANDMODE_POLYGONSELECTION
                
            
    if bs is not None :
                
    mode c4d.MODELINGCOMMANDMODE_POLYGONSELECTION
                bsc 
    bs.GetClone()
                
    bs obj.GetPolygonS()
                
    bs.DeselectAll()
                
    bs.Merge(bsc)
            
            return 
    c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_SUBDIVIDE, list=[obj], mode=modebc=bcdoc=doc

    FermerTrous




    Code PHP:
        def FermerTrous(objdoc) :
            
            
    """
                Ferme tous les trous d'un objet.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
            """
            
            
    polys obj.GetAllPolygons()
            
    c4d.utils.Neighbor()
            
    n.Init(obj)
            
    params c4d.BaseContainer()
            
    params[c4d.MDATA_CLOSEHOLE_INDEX] = obj
            params
    [c4d.MDATA_CLOSEHOLE_TRI] = True
            mode 
    c4d.MODELINGCOMMANDMODE_EDGESELECTION
            commande 
    c4d.ID_MODELING_CLOSEHOLE_TOOL
            
            SendModelingCommand 
    c4d.utils.SendModelingCommand
            
            
    for ipol in enumerate(polys) :
                
                
    nab n.GetNeighbor(pol.apol.bi)
                
    nbc n.GetNeighbor(pol.bpol.ci)
                
    ncd n.GetNeighbor(pol.cpol.di)
                
    nda n.GetNeighbor(pol.dpol.ai)
                
    cotes n.GetPolyInfo(i)["edge"]
                
                if 
    nab == c4d.NOTOK :
                    
    params[c4d.MDATA_CLOSEHOLE_EDGE] = cotes[0]
                    
    SendModelingCommand(command=commande, list=[obj], mode=modebc=paramsdoc=doc)
                    
    n.Init(obj)
                    
                if 
    nbc == c4d.NOTOK :
                    
    params[c4d.MDATA_CLOSEHOLE_EDGE] = cotes[1]
                    
    SendModelingCommand(command=commande, list=[obj], mode=modebc=paramsdoc=doc)
                    
    n.Init(obj)
                    
                if ((
    ncd == c4d.NOTOK) and (pol.!= pol.d)) :
                    
    params[c4d.MDATA_CLOSEHOLE_EDGE] = cotes[2]
                    
    SendModelingCommand(command=commande, list=[obj], mode=modebc=paramsdoc=doc)
                    
    n.Init(obj)
                    
                if 
    nda == c4d.NOTOK :
                    
    params[c4d.MDATA_CLOSEHOLE_EDGE] = cotes[3]
                    
    SendModelingCommand(command=commande, list=[obj], mode=modebc=paramsdoc=doc)
                    
    n.Init(obj)
            
            
    obj.Message(c4d.MSG_UPDATE

    BiseauterCommande


    Code PHP:
        def BiseauterCommande(objdocrayon 0.mode "chanfrein"subdivision 0limite False) :
            
            
    """
                Biseaute la sélection d'arêtes courante, en utilisant CallCommand.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                    rayon (float) - Rayon du biseau
                    mode (string) - Mode du biseau ('chanfrein' ou 'solide')
                    subdivision (int) - Subdivision
                    limite (bool) - Limite le rayon du biseau
            """
            
            
    mmode doc.GetMode()
            
    doc.SetMode(c4d.Medges)
            
    c4d.CallCommand(431000015431000015)
            
            
    tool c4d.plugins.FindPlugin(doc.GetAction(), c4d.PLUGINTYPE_TOOL)
            
            if 
    tool is not None :
                
                
    tool[c4d.MDATA_BEVEL_LIMIT] = limite
                tool
    [c4d.MDATA_BEVEL_SUB] = subdivision
                tool
    [c4d.MDATA_BEVEL_RADIUS] = rayon
                
                tool
    [c4d.MDATA_BEVEL_MASTER_MODE] = c4d.MDATA_BEVEL_MASTER_MODE_CHAMFER
                
                
    if mode == "solide" :
                    
    tool[c4d.MDATA_BEVEL_MASTER_MODE] = c4d.MDATA_BEVEL_MASTER_MODE_SOLID
                    
                c4d
    .CallButton(toolc4d.MDATA_APPLY)
                
            
    doc.SetMode(mmode

    BiseauterC4D


    Code PHP:
        def BiseauterC4D(objdocbsrayon 0.mode "chanfrein"subdivision 0limite False) :
            
            
    """
                Biseaute une sélection d'arêtes, en utilisant le déformateur Biseau. Renvoie l'objet biseauté.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                    bs (BaseSelect) - Sélection d'arêtes
                    rayon (float) - Rayon du biseau
                    mode (string) - Mode du biseau ('chanfrein' ou 'solide')
                    subdivision (int) - Subdivision
                    limite (bool) - Limite le rayon du biseau
                
                Renvoie :
                    (BaseObject ou None) - Objet biseauté
            """
            
            
    # Propriété Sélection d'arêtes
            
    propSelAretes obj.MakeTag(c4d.Tedgeselection)
            
    propSelAretes.SetName("SelAreBiseau")
            
    bsAre propSelAretes.GetBaseSelect()
            
    bsAre.Merge(bs)
            
            
    # Déformateur Biseau
            
    defBiseau c4d.BaseObject(431000028)
            
    defBiseau[c4d.O_BEVEL_MODE_COMPONENT_TYPE] = c4d.O_BEVEL_MODE_COMPONENT_TYPE_EDGE
            defBiseau
    [c4d.O_BEVEL_RESTRICTION_START] = propSelAretes.GetName()
            if 
    mode == "solide" defBiseau[c4d.O_BEVEL_MASTER_MODE] = c4d.O_BEVEL_MASTER_MODE_SOLID
            
    else : defBiseau[c4d.O_BEVEL_MASTER_MODE] = c4d.O_BEVEL_MASTER_MODE_CHAMFER
            defBiseau
    [c4d.O_BEVEL_RADIUS] = rayon
            defBiseau
    [c4d.O_BEVEL_SUB] = subdivision
            defBiseau
    [c4d.O_BEVEL_LIMIT] = limite
            defBiseau
    .InsertUnder(obj)
            
            
    res c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_CURRENTSTATETOOBJECT, list=[obj], doc=doc)
            
            if 
    res doc.InsertObject(res[0])
            
            
    propSelAretes.Remove()
            
    defBiseau.Remove()
            
            if 
    res : return res[0]
            return 
    None 

    ExtruderC4D


    Code PHP:
        def ExtruderC4D(objdocdecalagecapot Falsesubdivision 0ngones Falseangle 3.141592653589793) :
            
            
    """
                Extrude les polygones sélectionnés avec la méthode de C4D.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                    decalage (float) - Décalage de l'extrusion
                    capot (bool) - Créé ou non le capot
                    subdivision (int) - Subdivision de l'extrusion
                    ngones (bool) - Créé ou non des n-gones
                    angle (float) - Angle de limitation de cohésion des polygones extrudés
                
                Renvoie :
                    (bool) - Succès ou non
            """
            
            
    bc c4d.BaseContainer()
            
    bc[c4d.MDATA_EXTRUDE_PRESERVEGROUPS] = True
            bc
    [c4d.MDATA_EXTRUDE_OFFSET        ] = decalage
            bc
    [c4d.MDATA_EXTRUDE_VARIANCE      ] = 0.0
            bc
    [c4d.MDATA_EXTRUDE_ANGLE         ] = angle
            bc
    [c4d.MDATA_EXTRUDE_SUBDIVISION   ] = subdivision
            bc
    [c4d.MDATA_EXTRUDE_CREATENGONS   ] = ngones
            bc
    [c4d.MDATA_EXTRUDE_CREATECAPS    ] = capot
            
            
    return c4d.utils.SendModelingCommand(command c4d.ID_MODELING_EXTRUDE_TOOL,
                                    list = [
    obj],
                                    
    bc bc,
                                    
    mode c4d.MODELINGCOMMANDMODE_POLYGONSELECTION,
                                    
    doc doc

    Extruder




    Code PHP:
        def Extruder(objdecalagecapot Falsesubdivision 0bs NonenormalesPts NoneextrusionBi FalsefacteurDec None) :
            
            
    """
                Extrude les polygones. Renvoie le type de chaque polygone.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    decalage (float) - Décalage de l'extrusion
                    capot (bool) - Créé ou non les polygones du capot
                    subdivision (int) - Subdivision de l'extrusion
                    bs (BaseSelect) - Sélection de polygones à extruder
                    normalesPts (liste de Vector) - Direction de l'extrusion pour chaque point
                    extrusionBi (bool) - Extrude vers l'avant et l'arriète
                    facteurDec (liste de float) - Intensité de l'extrusion pour chaque point
                
                Renvoie :
                    (liste de int, ou None) - Liste d'entiers. Pour chaque polygone :
                        0 : Polygone original
                        1 : Face avant
                        2 : Tranche
                        3 : Face arrière
            """
            
            
    if obj is None or not obj.CheckType(c4d.Opolygon) : return None
            
            nbPts 
    obj.GetPointCount()
            
    nbPolys obj.GetPolygonCount()
            
    pts obj.GetAllPoints()
            
    polys obj.GetAllPolygons()
            if 
    bs is None :
                
    bs c4d.BaseSelect()
                
    bs.SelectAll(nbPolys-1)
            
    nbPolysSel 0
            nouvNbPolys 
    nbPolys
            
            
    if not capot extrusionBi False
            
    if extrusionBi decalage *= .5
            
            
    # Tableau pour les tableaux de marquage de retour
            
    tableauSel = [0] * nbPolys # 0 : Polygones originaux
            
    SEL_FACE_AVANT # Face avant
            
    SEL_FACE_TRANCHE # Tranche
            
    SEL_FACE_ARRIERE # Face arrière
            
            
    if decalage and capot :
                
    SEL_FACE_AVANTSEL_FACE_ARRIERE SEL_FACE_ARRIERESEL_FACE_AVANT
            
            
    if facteurDec is not None and len(facteurDec) != nbPts :
                
    facteurDec None
            
            
    if normalesPts is not None and len(normalesPts) != nbPts :
                
    normalesPts None
            
            
    if normalesPts is None :
                
    normalesPts VoncUtils.CalculeNormalesPoints(objbs)
            
            
    bsTout bs.GetAll(nbPolys)
            
            for 
    isel in enumerate(bsTout) :
                if 
    sel :
                    
    nbPolysSel += 1
                    tableauSel
    [i] = SEL_FACE_AVANT
            
            
    if nbPolysSel == : return None
            
            
            
    # Récupère les arêtes et les points de bordure
            
            
    aretesBordPoly VoncUtils.CalculeAretesBordureAvecPolys(objNonebs)
            
    nbBords len(aretesBordPoly) * (subdivision+1)
            
    ptsBords = [False] * nbPts
            
    for are in aretesBordPoly :
                
    ptsBords[are[0]] = True
                ptsBords
    [are[1]] = True
            
            
            
    # Récupère les points à extruder et compte le nombre de polys attachés à eux
            
            
    ptsAEx = [0] * nbPts
            
            
    for isel in enumerate(bsTout) :
                
                if 
    not sel : continue
                
                
    poly polys[i]
                
                
    ptsAEx[poly.a] += 1
                ptsAEx
    [poly.b] += 1
                ptsAEx
    [poly.c] += 1
                
    if poly.!= poly.ptsAEx[poly.d] += 1
            
            
            
    # Compte le nouveau nombre de points et créé la correspondance des anciens points vers ceux extrudés
            
            
    nouvNbPts nbPts
            ancPtVersNouv 
    = [0] * nbPts
            
            
    for isel in enumerate(ptsAEx) :
                
                
    # Si le point fait parti du base select des polys et, dans le cas sans capot, s'il fait parti des bords, le copier
                
    if sel != and (capot or ptsBords[i]) :
                    
                    
    ancPtVersNouv[i] = nouvNbPts
                    nouvNbPts 
    += 1
                    
                    
    if subdivision and ptsBords[i] : # Bordure
                    
                        
    nouvNbPts += subdivision
            
            
            
    # Créé les nouveaux points
            
            
    nouvPts = [c4d.Vector()] * (nouvNbPts nbPts)
            
    pts.extend(nouvPts)
            
            for 
    isel in enumerate(ptsAEx) :
                
                if 
    sel != :
                    
                    
    # Si bordure, prendre le point clone correspondant, sinon prendre le même qu'on bouge (cas sans capot)
                    
    i
                    
    if (capot or ptsBords[i]) : ancPtVersNouv[i]
                    
                    
    facDec decalage 0.
                    
    if facteurDec is not None :
                        
    facDec *= facteurDec[i]
                    
                    
    pts[j] = pts[i] + normalesPts[i] * facDec
                    
    if extrusionBi :
                        
    pts[i] = pts[i] - normalesPts[i] * facDec
                    
                    
    if subdivision and ptsBords[i] : # Bordure
                        
                        
    if not extrusionBi :
                            for 
    k in xrange(subdivision) :
                                
    pts[1] = pts[i] + normalesPts[i] * facDec * (1. - (1.) / (subdivision 1.))
                        else :
                            for 
    k in xrange(subdivision) :
                                
    pts[1] = pts[i] + normalesPts[i] * facDec * (1. - (1.) / (subdivision 1.)) * 2.
                            
            
            
    # Créé les polygones de tranche
            
            
    nouvNbPolys
            nouvNbPolys 
    += nbBords
            nouvPolys 
    = [None] * nbBords
            polys
    .extend(nouvPolys)
            
    tableauSel.extend([SEL_FACE_TRANCHE] * nbBords)
            
            for 
    are in aretesBordPoly :
                
                
    p0 are[0]
                
    p1 are[1]
                
    ipol are[2]
                
    pol polys[ipol]
                
                
    i0 pol.Find(p0)
                
    i1 pol.Find(p1)
                
                if 
    pol.IsTriangle() :
                    if 
    i0 == i0 2
                    
    if i1 == i1 2
                    
    if decalage 0. or not capot :
                        if 
    i0 == (i1 1) % 3:
                            
    p0p1 p1p0
                    
    else :
                        if 
    i1 == (i0 1) % 3:
                            
    p0p1 p1p0
                
                
    else :
                    if 
    decalage 0. or not capot :
                        if 
    i0 == (i1 1) % 4:
                            
    p0p1 p1p0
                    
    else :
                        if 
    i1 == (i0 1) % 4:
                            
    p0p1 p1p0
                
                p2 
    ancPtVersNouv[p1]
                
    p3 ancPtVersNouv[p0]
                
                if 
    subdivision :
                
                    for 
    i in xrange(subdivision 1) :
                        
                        
    poly c4d.CPolygon(
                            
    p0,
                            
    p1,
                            
    p2 subdivision i,
                            
    p3 subdivision i
                        
    )
                        
    polys[j] = poly
                        j 
    += 1
                        
                        p0 
    poly.d
                        p1 
    poly.c
                
                
    else :
                    
    poly c4d.CPolygon(
                        
    p0,
                        
    p1,
                        
    p2,
                        
    p3
                    
    )
                    
    polys[j] = poly
                    j 
    += 1
                
            aretesBordPoly 
    None
            
            
            
    # Créé les nouveaux polygones extrudés
            
            
    if capot :
                
                
    nouvNbPolys
                nouvNbPolys 
    += nbPolysSel
                nouvPolys 
    = [None] * nbPolysSel
                polys
    .extend(nouvPolys)
                
    tableauSel.extend([SEL_FACE_ARRIERE] * nbPolysSel)
                
                for 
    isel in enumerate(bsTout) :
                    
                    if 
    not sel : continue
                    
                    
    poly polys[i]
                    
                    
    nouvPoly None
                    
                    
    if decalage 0. :
                        
    nouvPoly c4d.CPolygon(
                            
    ancPtVersNouv[poly.a],
                            
    ancPtVersNouv[poly.b],
                            
    ancPtVersNouv[poly.c],
                            
    ancPtVersNouv[poly.d]
                        )
                    else :
                        
    nouvPoly c4d.CPolygon(
                            
    ancPtVersNouv[poly.d],
                            
    ancPtVersNouv[poly.c],
                            
    ancPtVersNouv[poly.b],
                            
    ancPtVersNouv[poly.a]
                        )
                    
                    
    polys[j] = nouvPoly
                    
    # tableauSel[j] = SEL_FACE_ARRIERE
                    
                    
    += 1
            
            
    else :
                
                for 
    isel in enumerate(bsTout) :
                    
                    if 
    not sel : continue
                    
                    
    poly polys[i]
                    
                    
    poly.a
                    b 
    poly.b
                    c 
    poly.c
                    d 
    poly.d
                    
                    poly
    .ancPtVersNouv[a] if capot or ptsBords[a] else a
                    poly
    .ancPtVersNouv[b] if capot or ptsBords[b] else b
                    poly
    .ancPtVersNouv[c] if capot or ptsBords[c] else c
                    
    if != :
                        
    poly.ancPtVersNouv[d] if capot or ptsBords[d] else d
                    
    else :
                        
    poly.poly.c
            
            
            
    # Si capot et décalage positif renverser les normales des polys du capot
            
            
    if capot and decalage 0. :
                
                for 
    isel in enumerate(bsTout) :
                    
                    if 
    not sel : continue
                    
                    
    poly polys[i]
                    
                    
    poly.a
                    b 
    poly.b
                    c 
    poly.c
                    d 
    poly.d
                    
                    
    if != :
                        
    poly.d
                        poly
    .c
                        poly
    .b
                        poly
    .a
                    
    else :
                        
    poly.b
                        poly
    .a
            
            
            
    # Applique les nouvelles coordonnées
            
            
    obj.ResizeObject(nouvNbPtsnouvNbPolys)
            
    obj.SetAllPoints(pts)
            for 
    ip in enumerate(polys) :
                
    obj.SetPolygon(ip)
                
            
    obj.Message(c4d.MSG_UPDATE)
            return 
    tableauSel 

    ReductionDePolys




    Code PHP:
        def ReductionDePolys(objdocintensitecourbe False) :
            
            
    """
                Applique le déformateur Réduction de polygones.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
                    intensite (float) - Intensité de la réduction (de 0.0 à 1.0)
                    courbe (bool) - Préserve la délimitation
                
                Renvoie :
                    (None ou BaseObject) - Objet réduit
            """
            
            
    # Déformateur Biseau
            
    defReduc c4d.BaseObject(c4d.Opolyreduction)
            
    defReduc[c4d.POLYREDUCTIONOBJECT_STRENGTH] = intensite
            defReduc
    [c4d.POLYREDUCTIONOBJECT_BOUNDARY] = courbe
            defReduc
    .InsertUnder(obj)
            
            
    res c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_CURRENTSTATETOOBJECT, list=[obj], doc=doc)
            
            if 
    res doc.InsertObject(res[0])
            
            
    defReduc.Remove()
            
            if 
    res : return res[0]
            return 
    None 

    SupprimerPolygones


    Code PHP:
        def SupprimerPolygones(objdoc) :
            
            
    """
                Supprime la sélection de polygones courante.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
            """
            
            
    c4d.utils.SendModelingCommand(command c4d.MCOMMAND_DELETE,
                                    list = [
    obj],
                                    
    mode c4d.MODELINGCOMMANDMODE_POLYGONSELECTION,
                                    
    doc doc
    Dernière modification par César Vonc ; 08/10/2017 à 13h45.

  5. #5
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Opérations sur les polygones


    AreteOpposee




    Code PHP:
        def AreteOpposee(p0p1poly) :
        
            
    """
                Renvoie l'arête opposée à deux points, ordonnée de façon symétrique aux points en paramètre.
                
                Paramètres :
                    p0 (int) - ID du premier point de l'arête
                    p1 (int) - ID du second point de l'arête
                    poly (CPolygon) - Polygone concerné
                
                Renvoie :
                    (tuple(int, int)) - ID du premier et du second point de l'arête opposée
            """
            
            
    arete poly.FindEdge(p0p1)
            if 
    arete == c4d.NOTOK :
                return (-
    1, -1)
            
            if 
    poly.== poly.# Triangle
            
                
    if p0 == poly.:
                    if 
    p1 == poly.: return (poly.cp1)
                    else : return (
    poly.bp1)
                    
                
    elif p0 == poly.:
                    if 
    p1 == poly.: return (poly.cp1)
                    else : return (
    poly.ap1)
                    
                else :
                    if 
    p1 == poly.: return (poly.bp1)
                    else : return (
    poly.ap1)
            
            
            
    areteOpp = (arete 2) % 4
            
            ptsOpp 
    poly.EdgePoints(areteOpp)
            
            if 
    poly.FindEdge(p0ptsOpp[0]) != c4d.NOTOK :
                return (
    ptsOpp[0], ptsOpp[1])
            else :
                return (
    ptsOpp[1], ptsOpp[0]) 

    AreteAdjacente




    Code PHP:
        def AreteAdjacente(p0p1poly) :
        
            
    """
                Renvoie l'arête adjacente à partir de deux points d'une arête.
                
                Paramètres :
                    p0 (int) - ID du premier point de l'arête
                    p1 (int) - ID du second point de l'arête
                    poly (CPolygon) - Polygone concerné
                
                Renvoie :
                    (tuple(int, int)) - ID du premier et du second point de l'arête adjacente, trié par ID
            """
            
            
    if p0 == p1 : return (-1, -1)
            
            if 
    poly.IsTriangle() :
            
                if 
    p0 == poly.:
                    if 
    p1 == poly.: return (poly.apoly.b) if poly.poly.else (poly.bpoly.a# 0, 1
                    
    else : return (poly.apoly.c) if poly.poly.else (poly.cpoly.a# 0, 2
                
                
    elif p0 == poly.
                    if 
    p1 == poly.: return (poly.bpoly.c) if poly.poly.else (poly.cpoly.b# 1, 2
                    
    else : return (poly.apoly.b) if poly.poly.else (poly.bpoly.a# 1, 0
                
                
    else :
                    if 
    p1 == poly.: return (poly.apoly.c) if poly.poly.else (poly.cpoly.a# 2, 0
                    
    else : return (poly.bpoly.c) if poly.poly.else (poly.cpoly.b# 2, 1
                
            
    else :
                if 
    p0 == poly.:
                    if 
    p1 == poly.: return (poly.apoly.b) if poly.poly.else (poly.bpoly.a# 0, 1
                    
    else : return (poly.apoly.d) if poly.poly.else (poly.dpoly.a# 0, 3
                
                
    elif p0 == poly.
                    if 
    p1 == poly.: return (poly.bpoly.c) if poly.poly.else (poly.cpoly.b# 1, 2
                    
    else : return (poly.apoly.b) if poly.poly.else (poly.bpoly.a# 1, 0
                
                
    elif p0 == poly.
                    if 
    p1 == poly.: return (poly.cpoly.d) if poly.poly.else (poly.dpoly.c# 2, 3
                    
    else : return (poly.bpoly.c) if poly.poly.else (poly.cpoly.b# 2, 1
                
                
    else :
                    if 
    p1 == poly.: return (poly.apoly.d) if poly.poly.else (poly.dpoly.a# 3, 0
                    
    else : return (poly.cpoly.d) if poly.poly.else (poly.dpoly.c# 3, 2
            
            
            
    return (-1, -1

    ListeAretesPolygone




    Code PHP:
        def ListeAretesPolygone(poly) :
        
            
    """
                Liste les arêtes d'un polygone.
                
                Paramètres :
                    poly (CPolygon) - Polygone
                
                Renvoie :
                    (tuple de tuple(int, int)) - Liste des arêtes, une arête étant un tuple trié de deux ID de points
            """
            
            
    if poly.IsTriangle() :
            
                return (
                    (
    poly.apoly.b) if (poly.poly.b) else (poly.bpoly.a),
                    (
    poly.bpoly.c) if (poly.poly.c) else (poly.cpoly.b),
                    (
    poly.cpoly.a) if (poly.poly.a) else (poly.apoly.c)
                )
            
            return (
                (
    poly.apoly.b) if (poly.poly.b) else (poly.bpoly.a),
                (
    poly.bpoly.c) if (poly.poly.c) else (poly.cpoly.b),
                (
    poly.cpoly.d) if (poly.poly.d) else (poly.dpoly.c),
                (
    poly.dpoly.a) if (poly.poly.a) else (poly.apoly.d)
            ) 

    ListeAretesPolygoneSensABCD




    Code PHP:
        def ListeAretesPolygoneSensABCD(poly) :
        
            
    """
                Liste les arêtes d'un polygone, les arêtes ici n'ont pas leurs indices triés.
                
                Paramètres :
                    poly (CPolygon) - Polygone
                
                Renvoie :
                    (tuple de tuple(int, int)) - Liste des arêtes, une arête étant ici un tuple non trié de deux ID de points
            """
            
            
    if poly.IsTriangle() :
            
                return (
                    (
    poly.apoly.b),
                    (
    poly.bpoly.c),
                    (
    poly.cpoly.a)
                )
            
            return (
                (
    poly.apoly.b),
                (
    poly.bpoly.c),
                (
    poly.cpoly.d),
                (
    poly.dpoly.a)
            ) 
    Dernière modification par César Vonc ; 08/10/2017 à 13h40.

  6. #6
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Opérations sur les matrices


    TransposeMatrice


    Code PHP:
        def TransposeMatrice(m) :
        
            
    """
                Transpose une matrice.
                
                Paramètres :
                    m (Matrix) - Matrice
            """
            
            
    v1 c4d.Vector(m.v1.xm.v2.xm.v3.x)
            
    v2 c4d.Vector(m.v1.ym.v2.ym.v3.y)
            
    v3 c4d.Vector(m.v1.zm.v2.zm.v3.z)
            
            
    m.v1 v1
            m
    .v2 v2
            m
    .v3 v3
            m
    .off c4d.Vector() 
    Dernière modification par César Vonc ; 08/10/2017 à 13h39.

  7. #7
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Opérations sur les vecteurs


    RefleteVecteur




    Code PHP:
        def RefleteVecteur(vn) :
        
            
    """
                Reflète un vecteur par rapport à une normale. La normale doit être normalisée.
                
                Paramètres :
                    v (Vector) - Vecteur initial
                    n (Vector) - Vecteur normale (normalisée)
                
                Renvoie :
                    (Vector) - Vecteur réfléchi
            """
            
            
    return (2. * (v.Dot(n)) * n) - 

    IntersectionSegments2DBool




    Code PHP:
        def IntersectionSegments2DBool(pp2qq2) :
            
            
    """
                Détermine si deux segments 2D se croisent.
                
                Paramètres :
                    p (Vector) - Point de départ du premier segment
                    p2 (Vector) - Point d'arrivée du premier segment
                    q (Vector) - Point de départ du second segment
                    q2 (Vector) - Point d'arrivée du second segment
                
                Renvoie :
                    (bool) - Booléen
            """
            
            
    def ccw(pp2q) :
                return (
    q.p.y) * (p2.p.x) > (p2.p.y) * (q.p.x)
            
            return 
    ccw(pqq2) != ccw(p2qq2) and ccw(pp2q) != ccw(pp2q2

    IntersectionSegments2DVector




    Code PHP:
        def IntersectionSegments2DVector(pp2qq2) :
            
            
    """
                Calcule le point d'intersection entre deux segments 2D.
                
                Paramètres :
                    p (Vector) - Point de départ du premier segment
                    p2 (Vector) - Point d'arrivée du premier segment
                    q (Vector) - Point de départ du second segment
                    q2 (Vector) - Point d'arrivée du second segment
                
                Renvoie :
                    (Vector ou None) - Point d'intersection
            """
            
            
    def CrossScal(av) :
                return 
    a.v.a.v.x
            
            r 
    p2 p
            s 
    q2 q
            rxs 
    CrossScal(rs)
            
    qpxr CrossScal((p), r)
        
            if 
    rxs == 0. :
                return 
    None
        
            t 
    CrossScal((p), s) / rxs
            u 
    CrossScal((p), r) / rxs
        
            
    if (<= and <= 1) and (<= and <= 1) :
                return 
    t*r
        
            
    return None 

    IntersectionDroites2DBool




    Code PHP:
        def IntersectionDroites2DBool(p1p2q1q2) :
            
            
    """
                Détermine si deux droites 2D se croisent.
                
                Paramètres :
                    p1 (Vector) - Point sur la première droite
                    p2 (Vector) - Point sur la première droite
                    q1 (Vector) - Point sur la seconde droite
                    q2 (Vector) - Point sur la seconde droite
                
                Renvoie :
                    (bool) - Booléen
            """
            
            
    pa p1.p2.y
            pb 
    p2.p1.x
            
            qa 
    q1.q2.y
            qb 
    q2.q1.x
            
            d  
    pa qb pb qa
            
            
    return != 0. 

    IntersectionDroites2DVector




    Code PHP:
        def IntersectionDroites2DVector(p1p2q1q2) :
            
            
    """
                Calcule le point d'intersection entre deux droites 2D.
                
                Paramètres :
                    p1 (Vector) - Point sur la première droite
                    p2 (Vector) - Point sur la première droite
                    q1 (Vector) - Point sur la seconde droite
                    q2 (Vector) - Point sur la seconde droite
                
                Renvoie :
                    (Vector ou None) - Point d'intersection
            """
            
            
    pa p1.p2.y
            pb 
    p2.p1.x
            pc 
    =  p2.p1.p1.p2.y
            
            qa 
    q1.q2.y
            qb 
    q2.q1.x
            qc 
    q2.q1.q1.q2.y
            
            d  
    pa qb pb qa
            dx 
    pc qb pb qc
            dy 
    pa qc pc qa
            
            
    if != 0. :
                return 
    c4d.Vector(dx ddy d0.)
            
            else :
                return 
    None 
    Dernière modification par César Vonc ; 08/10/2017 à 13h39.

  8. #8
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Sélections


    BaseSelectAretesToutes


    Code PHP:
        def BaseSelectAretesToutes(obj) :
            
            
    """
                Renvoie le BaseSelect de toutes les arêtes sélectionnées.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (BaseSelect) - Sélection de toutes les arêtes sélectionnées
            """
            
            
    bs c4d.BaseSelect()
            
    nbPolys obj.GetPolygonCount()
            
    bs.SelectAll(nbPolys 1)
            
            return 
    bs 

    BaseSelectPolysDepuisAretes




    Code PHP:
        def BaseSelectPolysDepuisAretes(objbsAretes) :
            
            
    """
                Renvoie le BaseSelect des polys ayant au moins une arête sélectionnée.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bsAretes (BaseSelect) - Sélection d'arêtes
                
                Renvoie :
                    (BaseSelect) - Sélection de polygones
            """
            
            
    bs c4d.BaseSelect()
            
    nbAretes obj.GetPolygonCount() * 4
            
            
    for isel in enumerate(bsAretes.GetAll(nbAretes)) :
                if 
    sel :
                    
    bs.Select(int(4))
            
            return 
    bs 

    BaseSelectPolysTous


    Code PHP:
        def BaseSelectPolysTous(obj) :
            
            
    """
                Renvoie le BaseSelect de tous les polygones sélectionnés.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                
                Renvoie :
                    (BaseSelect) - Sélection de polygones
            """
            
            
    bs c4d.BaseSelect()
            
    nbPolys obj.GetPolygonCount()
            
    bs.SelectAll(nbPolys 1)
            
            return 
    bs 

    SelectionnePointsTous


    Code PHP:
        def SelectionnePointsTous(obj) :
            
            
    """
                Sélectionne tous les points.
                
                Paramètres :
                    obj (PolygonObject) - Objet
            """
            
            
    if obj.CheckType(c4d.Opoint) :
                
    bs obj.GetPointS()
                
    bs.SelectAll(obj.GetPointCount() - 1

    SelectionnePointsPolysPoints




    Code PHP:
        def SelectionnePointsPolysPoints(objnei None) :
            
            
    """
                Sélectionne tous les points des polys des points sélectionnés.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    nei (Neighbor) - Neighbor initialisé
            """
            
            
    if not obj.CheckType(c4d.Opolygon) : return
            
            if 
    not nei :
                
    nei c4d.utils.Neighbor()
                
    nei.Init(obj)
            
            
    nbPts obj.GetPointCount()
            
    polys obj.GetAllPolygons()
            
    bs obj.GetPointS()
            
    bs2 c4d.BaseSelect()
            
    bsTous bs.GetAll(nbPts)
            
            for 
    isel in enumerate(bsTous) :
                if 
    not sel : continue
                
    vois nei.GetPointPolys(i)
                for 
    voi in vois :
                    
    pol polys[voi]
                    
    bs2.Select(pol.a)
                    
    bs2.Select(pol.b)
                    
    bs2.Select(pol.c)
                    if 
    pol.!= pol.bs2.Select(pol.d)
            
            
    bs.Merge(bs2

    SelectionnePolysTous


    Code PHP:
        def SelectionnePolysTous(obj) :
            
            
    """
                Sélectionne tous les polygones.
                
                Paramètres :
                    obj (PolygonObject) - Objet
            """
            
            
    if obj.CheckType(c4d.Opolygon) :
                
    bs obj.GetPolygonS()
                
    bs.SelectAll(obj.GetPolygonCount() - 1

    SelectionnePolysInverse


    Code PHP:
        def SelectionnePolysInverse(obj) :
            
            
    """
                Inverse la sélection de polys courante.
                
                Paramètres :
                    obj (PolygonObject) - Objet
            """
            
            
    if obj.CheckType(c4d.Opolygon) :
                
    bs obj.GetPolygonS()
                
    bs.ToggleAll(0obj.GetPolygonCount() - 1

    SelectionnePolysAucun


    Code PHP:
        def SelectionnePolysAucun(obj) :
            
            
    """
                Désélectionne tous les polygones.
                
                Paramètres :
                    obj (PolygonObject) - Objet
            """
            
            
    if obj.CheckType(c4d.Opolygon) :
                
    bs obj.GetPolygonS()
                
    bs.DeselectAll() 

    SelectionneAretesToutes


    Code PHP:
        def SelectionneAretesToutes(objdoc) :
            
            
    """
                Sélectionne toutes les arêtes.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
            """
            
            
    c4d.utils.SendModelingCommand(command c4d.MCOMMAND_SELECTALL,
                                    list = [
    obj],
                                    
    mode c4d.MODELINGCOMMANDMODE_EDGESELECTION,
                                    
    doc doc

    SelectionneAretesInverse


    Code PHP:
        def SelectionneAretesInverse(objdoc) :
            
            
    """
                Inverse la sélection d'arêtes courante.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    doc (BaseDocument) - Document
            """
            
            
    c4d.utils.SendModelingCommand(command c4d.MCOMMAND_SELECTINVERSE,
                                    list = [
    obj],
                                    
    mode c4d.MODELINGCOMMANDMODE_EDGESELECTION,
                                    
    doc doc

    SelectionneAretesAucune


    Code PHP:
        def SelectionneAretesAucune(obj) :
            
            
    """
                Désélectionne toutes les arêtes.
                
                Paramètres :
                    obj (PolygonObject) - Objet
            """
            
            
    if obj.CheckType(c4d.Opolygon) :
                
    bs obj.GetEdgeS()
                
    bs.DeselectAll() 

    SelectionneAretesContour




    Code PHP:
        def SelectionneAretesContour(objNone) :
        
            
    """
                Sélectionne les arêtes de contour.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    n (Neighbor) - Neighbor initialisé
            """
            
            
    if not obj : return
            if 
    obj.GetType() != c4d.Opolygon: return
            
            
    nbPolys obj.GetPolygonCount()
            
    polys obj.GetAllPolygons()
            
    bs c4d.BaseSelect()
            
    bsAre obj.GetEdgeS().GetClone()
            
            if 
    n is None :
                
    c4d.utils.Neighbor()
                
    n.Init(obj)
            
            for 
    ipol in enumerate(polys):
                
                
    pa pol.a
                pb 
    pol.b
                pc 
    pol.c
                pd 
    pol.d
                
                nab 
    n.GetNeighbor(papbi)
                
    nbc n.GetNeighbor(pbpci)
                
    ncd n.GetNeighbor(pcpdi)
                
    nda n.GetNeighbor(pdpai)
                
                
    cotes n.GetPolyInfo(i)["edge"]
                
                if 
    nab == -1:
                    
    bs.Select(cotes[0])
                if 
    nbc == -1:
                    
    bs.Select(cotes[1])
                if 
    ncd == -1:
                    if 
    pc != pdbs.Select(cotes[2])
                if 
    nda == -1:
                    
    bs.Select(cotes[3])
            
            
    obj.SetSelectedEdges(nbsc4d.EDGESELECTIONTYPE_SELECTION)
            
    bs obj.GetEdgeS()
            
    bs.Merge(bsAre

    MarquagePointsDepuisAretes




    Code PHP:
        def MarquagePointsDepuisAretes(objbsAretes NonebsAretesGetAll None) :
        
            
    """
                Renvoie un tableau de marquage des points sélectionnés à partir d'une sélection d'arêtes.
                
                Paramètres :
                    obj (PolygonObject) - Objet
                    bsAretes (BaseSelect) - Sélection d'arêtes
                    bsAretesGetAll (liste de int) - GetAll() du bsAretes
                    
                Renvoie :
                    (liste de bool) - Liste de booléens marquants les points sélectionnés des arêtes sélectionnées.
            """
            
            
    polys obj.GetAllPolygons()
            
    nbPolys obj.GetPolygonCount()
            
    nbPts obj.GetPointCount()
            
            if 
    bsAretes is None :
                
    bsAretes obj.GetEdgeS()
            
            if 
    bsAretesGetAll is None :
                
    bsAretesGetAll bsAretes.GetAll(nbPolys 4)
            
            
    ptsSel = [False] * nbPts
            
            
    for ipol in enumerate(polys) :
                
                if 
    not bsAretesGetAll[i*4] and not bsAretesGetAll[i*4+1] and not bsAretesGetAll[i*4+2] and not bsAretesGetAll[i*4+3] : continue
                
                
    aretesPolySensABCD VoncUtils.ListeAretesPolygoneSensABCD(pol)
                
                for 
    jare in enumerate(aretesPolySensABCD) :
                    if 
    bsAretesGetAll[i*j] :
                        
    ptsSel[are[0]] = True
                        ptsSel
    [are[1]] = True
                
                
    if pol.== pol.:
                    if 
    bsAretesGetAll[i*3] :
                        
    are aretesPolySensABCD[2]
                        
    ptsSel[are[0]] = True
                        ptsSel
    [are[1]] = True
                
            
    return ptsSel 

    AffichePolysTous


    Code PHP:
        def AffichePolysTous(obj) :
            
            
    """
                Affiche tous les polygones.
                
                Paramètres :
                    obj (PolygonObject) - Objet
            """
            
            
    if obj.CheckType(c4d.Opolygon) :
                
    bs obj.GetPolygonH()
                
    bs.DeselectAll() 

    AffichePointsTous


    Code PHP:
        def AffichePointsTous(obj) :
            
            
    """
                Affiche tous les polygones.
                
                Paramètres :
                    obj (PolygonObject) - Objet
            """
            
            
    if obj.CheckType(c4d.Opolygon) :
                
    bs obj.GetPointH()
                
    bs.DeselectAll() 

    AfficheAretesToutes


    Code PHP:
        def AfficheAretesToutes(obj) :
            
            
    """
                Affiche toutes les arêtes.
                
                Paramètres :
                    obj (PolygonObject) - Objet
            """
            
            
    if obj.CheckType(c4d.Opolygon) :
                
    bs obj.GetEdgeH()
                
    bs.DeselectAll() 
    Dernière modification par César Vonc ; 08/10/2017 à 13h42.

  9. #9
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Débug


    DebugVecteur


    Code PHP:
        def DebugVecteur(docaNonecoul c4d.Vector(1.), nom "vec") :
            
            
    """
                Ajoute un vecteur au document.
                
                Paramètres :
                    doc (BaseDocument) - Document
                    a (Vector) - Position de début
                    b (Vector) - Position de fin
                    coul (Vector) - Couleur du vecteur
                    nom (string) - Nom du vecteur
            """
            
            
    groupe doc.SearchObject("debug")
            
            if 
    groupe is None :
                
    groupe c4d.BaseObject(c4d.Onull)
                
    groupe.SetName("debug")
                
    doc.InsertObject(groupe)
                
    doc.AddUndo(c4d.UNDOTYPE_NEWgroupe)
            
            
            
    None
            
            
    if b is None :
                
    c4d.BaseObject(c4d.Onull)
                
    p[c4d.NULLOBJECT_DISPLAY] = 1
                p
    [c4d.NULLOBJECT_RADIUS] = 3.
                
            
    else :
                
    c4d.BaseObject(c4d.Ospline)
                
    p.ResizeObject(2)
                
    p.SetAllPoints([c4d.Vector(), a])
                
    p.Message(c4d.MSG_UPDATE)


            
    p.SetName(nom)
            
    p[c4d.ID_BASEOBJECT_USECOLOR] = 2
            p
    [c4d.ID_BASEOBJECT_COLOR] = coul
            p
    [c4d.ID_BASEOBJECT_REL_POSITION] = a
            p
    .InsertUnder(groupe)
            
    doc.AddUndo(c4d.UNDOTYPE_NEWp

    DebugTexte


    Code PHP:
        def DebugTexte(docpos c4d.Vector(), texte "texte"taille 16.coul c4d.Vector(1.)) :
            
            
    """
                Ajoute un texte au document.
                
                Paramètres :
                    doc (BaseDocument) - Document
                    pos (Vector) - Position
                    texte (string) - Texte à afficher
                    taille (float) - Taille de la police
                    couleur (Vector) - Couleur de la police
            """
            
            
    groupe doc.SearchObject("debug")
            
            if 
    groupe is None :
                
    groupe c4d.BaseObject(c4d.Onull)
                
    groupe.SetName("debug")
                
    doc.InsertObject(groupe)
                
    doc.AddUndo(c4d.UNDOTYPE_NEWgroupe)
            
            
            
    c4d.BaseObject(1019268)
            
    p.MakeTag(1001001)
            
    p[c4d.PRIM_TEXT_VSPACING] = - taille + (taille 4.)
            
    p[c4d.ID_BASEOBJECT_USECOLOR] = 2
            p
    [c4d.ID_BASEOBJECT_COLOR] = coul
            p
    [c4d.PRIM_TEXT_HEIGHT] = taille
            p
    [c4d.ID_BASEOBJECT_REL_SCALE,c4d.VECTOR_X] = -1.
            p
    [c4d.PRIM_TEXT_ALIGN] = 1
            p
    [c4d.MGTEXTOBJECT_SPLINEMOVE] = 0.
            p
    [c4d.PRIM_TEXT_TEXT] = "\n" texte
            p
    [c4d.ID_BASEOBJECT_REL_POSITION] = pos
            
            p
    .InsertUnder(groupe)
            
    doc.AddUndo(c4d.UNDOTYPE_NEWp
    Dernière modification par César Vonc ; 08/10/2017 à 12h39.

  10. #10
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Réservé.

  11. #11
    Pilier Avatar de clemz
    Date d'inscription
    février 2009
    C4D version
    R15 Studio
    OS
    windaube x64
    Messages
    1 925
    waouw merci César .

    j'ai encore du mal avec Python mais tout ça me sera surement bien utile !

  12. #12
    Vieux Croûton Avatar de Aurety
    Date d'inscription
    juillet 2002
    C4D version
    R17 Studio
    OS
    Mac
    Messages
    14 148
    Billets dans le blog
    3
    Ca donne envie de s'y mettre ! En tout les cas, c'est un travail extraordinaire.
    kenavo !! // Pinterest KAMIGAZ®

  13. #13
    Pilier Avatar de oli_d
    Date d'inscription
    avril 2004
    C4D version
    R19 Studio
    OS
    MacOS X
    Messages
    633
    Superbe, quel boulot ! Merci beaucoup pour le partage, c'est vraiment super utile. Et hop, c'est déjà dans mon dossier site-packages .

  14. #14
    Gourou Avatar de César Vonc
    Date d'inscription
    avril 2006
    C4D version
    R19 Studio
    OS
    Windows 10
    Messages
    2 298
    Merci, lance-toi Aurety, tu verras, c'est addictif.

  15. #15
    Gourou Avatar de valkaari
    Date d'inscription
    mai 2009
    C4D version
    R17 Studio
    OS
    OSX Madick
    Messages
    2 763
    Bravo pour le taf, tu devrais coller ça sur un github ou autre. On pourrais particichier

    je l'ai pas vu je sais pas si tu l'as, j'en ai eu besoin pour une triangulation Delaunay on trouve la formule un peu partout.

    Code:
    def CercleCirconscrit(A,B,C):
        """ 
        renvoie le centre du cercle circonscrit et son rayon
        """
        a = A-C
        b = B-C
        n = b.Cross(a)
        p0 = n.Cross( a.Dot(a) * b - b.Dot(b)*a) * (0.5 / n.Dot(n)) + C
        r = 0.25 * a.Dot(a) * b.Dot(b) * (a-b).Dot(a-b) / n.Dot(n)
        return p0, math.sqrt(r)
    Dernière modification par valkaari ; Hier à 08h33.

  16. #16
    Pilier Avatar de gr4ph0s
    Date d'inscription
    mai 2013
    C4D version
    R16 Studio
    OS
    win 7 X64
    Messages
    774
    +1 pour le github ! En tout cas super documentations !

    Voici quelques fonctions pour la gestions des VertexMaps dans c4d, qui n'est pas vraiment accessible en python.
    https://gist.github.com/gr4ph0s/1bc0...678531a37f065b

    Ou encore un simple script de LookAt entre deux objets
    Code:
    def LookAt(SrcObj, DestObj, RightNormalized=c4d.Vector(0,1,0)):    
        if not SrcObj or not DestObj:
            return
        
        #Get global pos
        srcPos = SrcObj.GetMg().off
        destPos = DestObj.GetMg().off
        
        #Build front axis
        forward = srcPos - destPos
        forward.Normalize()
        
        #Build right axis
        right = RightNormalized.GetNormalized().Cross(forward)
        
        #Build up axis
        up = forward.Cross(right)
        
        #Build the final matrice
        m = SrcObj.GetMg()
        m.v1 = right
        m.v2 = up
        m.v3 = forward
        
        #Set new matrice
        scale = SrcObj.GetRelScale()
        SrcObj.SetMg(m)
        SrcObj.SetRelScale(scale)
        
        c4d.EventAdd()
    Dernière modification par gr4ph0s ; Hier à 11h00.
    3D 3e année MJM NANTES

    Website : graphos.xyz

Discussions similaires

  1. Déformateur Utilitaires
    Par César Vonc dans le forum Plugins made in FC4D
    Réponses: 6
    Dernier message: 09/07/2017, 17h35
  2. Tuto vidéo Python - 02 Introduction au SDK python
    Par gr4ph0s dans le forum Xpresso/Programmation
    Réponses: 4
    Dernier message: 09/02/2017, 17h20
  3. [Résolu] Importer script python dans un plugin python
    Par Pandoxyd dans le forum Nouveaux membres
    Réponses: 8
    Dernier message: 28/09/2016, 10h48
  4. Tuto vidéo Python - 01 Introduction Au python
    Par gr4ph0s dans le forum Xpresso/Programmation
    Réponses: 8
    Dernier message: 09/09/2016, 16h07
  5. Foire aux utilitaires OSX
    Par NiKo dans le forum Le saloon
    Réponses: 5
    Dernier message: 17/03/2008, 18h22

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •