Nodo British Museum - Scripting in Generative Components

Come avevo detto, ho pensato che sarebbe stato più semplice popolare una superficie con dei poligoni esagonali invece di usare il nodo modellato in precedenza.

Ho iniziato quindi inserendo 3 punti dai quali verrano create delle linee e di sonseguenza una superficie:

1. Inserimento di 3 punti

2. Creazione di linee tramite i punti inseriti

3. Creazione di una superficie tramite un comando sweep tra le linee

Procedendo con il posizionamento di una griglia di punti sulla superficie creata, ho poi inserito una GraphFunction che dia la possibilità di creare dei poligoni esagonali aventi come punti centrali tutti i punti della griglia

 4. Inserimento griglia di punti sulla superficie

---------------------------------------------------------------------------------------------------

transaction modelBased "Functions"
{
    feature graphFunction02 Bentley.GC.GraphFunction
    {
        Definition                = function (Point ptGd, int floors, int bays)
                                    {  
                                        Polygon pol = {};
                                        int hexi = 0;
                                        int hexj = 0;
                                        int col = 0;
                                        Point verts = {};
                                        int shift = 0;
                                       
                                        int patternOffseti = {0, 1, 2, 2, 1, 0};
                                                          
                                        int patternOffsetj = {0, 0, 1, 2, 2, 1};
                                           
                                        for (int i = 0; i < floors-3; i=i+1)   
                                        {       
                                           
                                            if (col%2!=0)
                                            {
                                                shift = 1;
                                            }
                                            else
                                            {
                                                shift = 0;
                                            }
                                           
                                            pol[hexi] = {};
                                            for (int j = 0; j < bays-2; j=j+1)
                                            { 
                                                for (int k = 0; k < 6; k++)
                                                {                                  
                                                    verts[k] = ptGd[ i + patternOffseti[k]][ j + patternOffsetj[k] + shift ];
                                                }
                                                pol[hexi][hexj] = new Polygon();
                                                pol[hexi][hexj].ByVertices(verts);
                                                hexj++;
                                               
                                            }
                                            hexi++;
                                            col++;
                                        }   
                                        return pol;
                                        };
        SymbolXY                  = {101, 101};
    }
}
 

--------------------------------------------------------------------------------------------------

 5. Funzione per creare poligoni esagonali sulla griglia di punti

6. Poligoni esagonali creati tramite la GraphFunction

A questo punto per conoscere gli angoli tra le aste della supeficie devo prima disegnarle tra i punti centrali di ogni poligono ed i vertici dei poligoni stessi.

7. Creazione dei punti  centroidi di tutti i poligoni coincidenti con i punti della griglia (ai bordi i punti sono sfalsati poichè i poligoni sono troncati)

8. Creazione delle linee (aste) tra i centroidi ed i vertici dei poligoni

Infine ho trovato sulla Community della Bentley in questo post:

http://communities.bentley.com/forums/thread/13903.aspx

una funzione che serve per calcolare un angolo dati 3 punti, dove il secondo è il punto d'origine dell'angolo.

A questa funzione io ho aggiunto una GraphVariable che sia capace di leggere l'angolo in questione  ed una Feature che scriva la variabile sul punto centrale.

----------------------------------------------------------------------------------------------------

transaction modelBased "Add vectorAngle360Function"
{
    feature vectorAngle360Function Bentley.GC.GraphFunction
    {
        Definition                = double function (CoordinateSystem cs, Point thisFirstPoint, Point thisAngleOrigin, Point thisThirdPoint)
                                    {
                                        // function to calculate zero to 360 angle between three points
                                        // angle is measured first to third point in mathematical positive orientation
                                        // when first, origin, third are x, origin, and "y" point
                                   
                                    //    breakpoint;
                                       
                                        CoordinateSystem thePointsCoordSystem = new CoordinateSystem();
                                        double retAngle = 180.0;
                                        Point tfFirstPnt = new Point();
                                        Point tfThirdPnt = new Point();
                                        Point fakeZPnt = new Point();
                                        Point tfFakeZPnt = new Point();
                                       
                                        // thePointsCoordSystem.ByOriginXYPoints(thisAngleOrigin, thisFirstPoint, thisThirdPoint);
                                        thePointsCoordSystem.ByOriginXPoint(thisAngleOrigin, thisThirdPoint);
                                        fakeZPnt.ByCartesianCoordinates(thePointsCoordSystem, 0.0, 0.0, 5000.0);
                                       
                                        // transfer the points to local coordinates to calculate angles in local xy
                                       
                                        tfFirstPnt.CopyTransformGeometricContents(thisFirstPoint, thePointsCoordSystem, cs);
                                        tfThirdPnt.CopyTransformGeometricContents(thisThirdPoint, thePointsCoordSystem, cs);
                                        tfFakeZPnt.CopyTransformGeometricContents(fakeZPnt, thePointsCoordSystem, cs);
                                       
                                        retAngle = Objects.Angle(cs, tfFirstPnt, tfThirdPnt);
                                       
                                        if(tfFirstPnt.Y < 0.0)  retAngle = 360.0 - retAngle;
                                       
                                        return(retAngle);
                                    };
        SymbolXY                  = {104, 92};
    }
}

transaction modelBased "Add angle"
{
    feature angle Bentley.GC.GraphVariable
    {
        Value                     = vectorAngle360Function (baseCS,line03[0].EndPoint,point05[0][0][1],line03[1].EndPoint);
    }
}

---------------------------------------------------------------------------------------------------------

9. Funzione che calcola l'angolo dati 3 punti

----------------------------------------------------------------------------------------------------------

transaction modelBased "Add angle"
{
    feature angle Bentley.GC.GraphVariable
    {
        Value                     = vectorAngle360Function (baseCS,line03[0].EndPoint,point05[0][0][1],line03[1].EndPoint);
    }
}

transaction modelBased "Add RealAngle"
{
    feature RealAngle Bentley.GC.GraphVariable
    {
        Value                     = 360-angle;
    }
}

transaction modelBased "Add text to evaluate the angle"
{
    feature text02 Bentley.GC.Text
    {
        Placement                 = point05[0][0][1];
        TextString                = ToString(RealAngle);
    }
}

-------------------------------------------------------------------------------------------------------------

10. Funzioni che leggono e scrivono i valori degli angoli

11. Valore dell'angolo tra l'asta selezionata e l'asta orizzontale