SuperEllipsoidModel.cpp

Go to the documentation of this file.

/* Copyright (c) 2014-2017, ARM Limited and Contributors
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "Common.h"
#include "SuperEllipsoidModel.h"

#include <cstdlib>

namespace MaliSDK
{      
    void SuperEllipsoidModel::create(int     samples,
                                     float   n1,
                                     float   n2,
                                     float   scale,
                                     float** roundedCubeCoordinates,
                                     float** roundedCubeNormalVectors,
                                     int*    numberOfVertices,
                                     int*    numberOfCoordinates,
                                     int*    numberOfNormals)
    {
        /* Check if samples is greater than 0. */
        ASSERT(samples > 0, "Number of samples has to be greater than 0.");

        ASSERT(roundedCubeCoordinates   != NULL, "Cannot use null pointer while calculating rounded cube coordinates.");
        ASSERT(roundedCubeNormalVectors != NULL, "Cannot use null pointer while calculating rounded cube normals.");
        ASSERT(numberOfVertices         != NULL, "Invalid parameter: cannot use NULL pointer to store number of vertices.");
        ASSERT(numberOfCoordinates      != NULL, "Invalid parameter: cannot use NULL pointer to store number of coordinates.");
        ASSERT(numberOfNormals          != NULL, "Invalid parameter: cannot use NULL pointer to store number of normals.");

        /* Computation of the numberOfCoordinates results from the algorithm used in this function.
         * In the first "for" loop we can see that this loop iterates samples / 2 times. Then in the second loop
         * we can see that this loop will go samples times. 
         * In total, there are samples / 2 * samples iterations.
         * Each iteration produces 6 vertices and each vertex has 4 coordinates. */
        *numberOfVertices    = samples / 2 * samples * 6;
        *numberOfCoordinates = *numberOfVertices * numberOfPointCoordinates;

        /* The number of normals is the same except that each normal only has 3 coordinates. */
        *numberOfNormals = samples / 2 * samples * 6 * numberOfPointCoordinates;

        /* Allocate memory to store rounded cube's coordinates. */
        *roundedCubeCoordinates   = new float[*numberOfCoordinates];
        /* Allocate memory to store rounded cube's normal vectors. */
        *roundedCubeNormalVectors = new float[*numberOfNormals];

        /* Make sure allocation succeeded. */
        ASSERT(roundedCubeCoordinates   != NULL, "Pointer roundedCubeCoordinates is NULL.");
        ASSERT(roundedCubeNormalVectors != NULL, "Pointer roundedCubeNormalVectors is NULL.");

            /* Values to store temporarily vertices and normal vectors. */
        Vec3f vertex, normalVector;

            /* Value vertexIndex determines the beginning of array where vertices should be saved. */
            int vertexIndex = 0;

            /* Value normalVectorIndex determines the beginning of array where normal vectors should be saved. */
            int normalVectorIndex = 0;
 
            /* These values will change xzAngle and xyAngle. */
        float xzAngleDelta = 2.0f * M_PI / samples;
        float xyAngleDelta = 2.0f * M_PI / samples;
 
            /* Angle used to compute vertices and normal vectors. */
        float xyAngle = -M_PI / 2.0f;
 
            /* This loop goes samples / 2 times because in each second loop we create 2 triangles. */
        for (int j = 0; j < samples / 2; j++)
        {
            /* Angle used to compute vertices and normal vectors. */
            float xzAngle = -M_PI;
 
            for (int i = 0; i < samples; i++)
            {
                /* Triangle #1 */
                /* Calculate first vertex and normal vector. */
                vertex       = sample         (xyAngle, xzAngle, n1, n2, scale);
                normalVector = calculateNormal(xyAngle, xzAngle, n1, n2, scale);

                /* Put vertex and normal vector coordinates into array. */
                storeVertexAndNormalVectorInArray(vertex,
                                                  normalVector,
                                                  vertexIndex,
                                                  normalVectorIndex,
                                                  *roundedCubeCoordinates,
                                                  *roundedCubeNormalVectors);

                /* Calculate second vertex and normal vector. */
                vertex       = sample         (xyAngle + xyAngleDelta, xzAngle, n1, n2, scale);
                normalVector = calculateNormal(xyAngle + xyAngleDelta, xzAngle, n1, n2, scale);

                /* Put vertex and normal vector coordinates into array. */
                storeVertexAndNormalVectorInArray(vertex,
                                                  normalVector,
                                                  vertexIndex,
                                                  normalVectorIndex,
                                                  *roundedCubeCoordinates,
                                                  *roundedCubeNormalVectors);

                /* Calculate third vertex and normal vector. */
                vertex       = sample         (xyAngle + xyAngleDelta, xzAngle + xzAngleDelta, n1, n2, scale);
                normalVector = calculateNormal(xyAngle + xyAngleDelta, xzAngle + xzAngleDelta, n1, n2, scale);

                /* Put vertex and normal vector coordinates into array. */
                storeVertexAndNormalVectorInArray(vertex,
                                                  normalVector,
                                                  vertexIndex,
                                                  normalVectorIndex,
                                                  *roundedCubeCoordinates,
                                                  *roundedCubeNormalVectors);
 
                /* Triangle #2 */
                /* Calculate first vertex and normal vector. */
                vertex       = sample         (xyAngle, xzAngle, n1, n2, scale);
                normalVector = calculateNormal(xyAngle, xzAngle, n1, n2, scale);

                /* Put vertex and normal vector coordinates into array. */
                storeVertexAndNormalVectorInArray(vertex,
                                                  normalVector,
                                                  vertexIndex,
                                                  normalVectorIndex,
                                                  *roundedCubeCoordinates,
                                                  *roundedCubeNormalVectors);

                /* Calculate second vertex and normal vector. */
                vertex       = sample         (xyAngle + xyAngleDelta,
                                               xzAngle + xzAngleDelta,
                                               n1,
                                               n2,
                                               scale);
                normalVector = calculateNormal(xyAngle + xyAngleDelta,
                                               xzAngle + xzAngleDelta,
                                               n1,
                                               n2,
                                               scale);

                /* Put vertex and normal vector coordinates into array. */
                storeVertexAndNormalVectorInArray(vertex,
                                                  normalVector,
                                                  vertexIndex,
                                                  normalVectorIndex,
                                                  *roundedCubeCoordinates,
                                                  *roundedCubeNormalVectors);

                /* Calculate third vertex and normal vector. */
                vertex       = sample         (xyAngle, xzAngle + xzAngleDelta, n1, n2, scale);
                normalVector = calculateNormal(xyAngle, xzAngle + xzAngleDelta, n1, n2, scale);

                /* Put vertex and normal vector coordinates into array. */
                storeVertexAndNormalVectorInArray(vertex,
                                                  normalVector,
                                                  vertexIndex,
                                                  normalVectorIndex,
                                                  *roundedCubeCoordinates,
                                                  *roundedCubeNormalVectors);
 
                /* Change xzAngle value. */
                xzAngle += xzAngleDelta;
            }

            /* Change xyAngle value. */
            xyAngle += xyAngleDelta;
        }
    }

    Vec3f SuperEllipsoidModel::calculateNormal(float xyAngle,
                                               float xzAngle,
                                               float n1,
                                               float n2,
                                               float scale)
    { 
             /* Pre-calculate sine and cosine values for both angles. */
         float cosPhi  = cosf(xyAngle);
             float cosBeta = cosf(xzAngle);
         float sinPhi  = sinf(xyAngle);
             float sinBeta = sinf(xzAngle);

        /* The equations for x, y and z coordinates are:
         * x = 1 / rx * cos^(2 - n1)(xyAngle) * cos^(2 - n2)(xzAngle)
         * y = 1 / ry * sin^(2 - n1)(xyAngle)
         * z = 1 / rz * cos^(2 - n1)(xyAngle) * sin^(2 - n2)(xzAngle)
         *
         * where:
         * -M_PI/2 <= xyAngle <= M_PI/2
         * -M_PI   <= xzAngle <= M_PI
         * 0 < n1, n2 < infinity
         *
         * As for two-dimensional case rx, ry, and rz are scale factors for each axis (axis intercept). */

         /* Normal vector to be returned. */
         Vec3f normal;
 
         normal.x = signum(cosPhi) * powf(fabs(cosPhi), 2 - n1) * signum(cosBeta) * powf(fabs(cosBeta), 2 - n2) / scale;
             normal.y = signum(sinPhi) * powf(fabs(sinPhi), 2 - n1) / scale;
         normal.z = signum(cosPhi) * powf(fabs(cosPhi), 2 - n1) * signum(sinBeta) * powf(fabs(sinBeta), 2 - n2) / scale;
 
             /* Normalize vector. */
         normal.normalize();
 
         return normal;
    }

    Vec3f SuperEllipsoidModel::sample(float xyAngle,
                                      float xzAngle,
                                      float n1,
                                      float n2,
                                      float scale)
    {
        /* Pre-calculate sine and cosine values for both angles. */
        const float xyAngleCos = cosf(xyAngle); 
        const float xzAngleCos = cosf(xzAngle);
        const float xyAngleSin = sinf(xyAngle); 
        const float xzAngleSin = sinf(xzAngle);

        /* The equations for x, y and z coordinates are given below:
         *
         * x = rx * cos^n1(xyAngle) * cos^n2(xzAngle)
         * y = ry * sin^n1(xyAngle)
         * z = rz * cos^n1(xyAngle) * sin^n2(xzAngle)
         *
         * where:
         *
         * -M_PI/2 <= xyAngle <= M_PI/2
         * -M_PI   <= xzAngle <= M_PI
         * 0 < n1, n2 < infinity
         *
         * As for two-dimensional case rx, ry, and rz are scale factors for each axis (axis intercept). */

        /* Vertex to be returned. */ 
        Vec3f vertex;

        vertex.x = scale * signum(xyAngleCos) * powf(fabs(xyAngleCos), n1) * signum(xzAngleCos) * powf(fabs(xzAngleCos), n2);
        vertex.y = scale * signum(xyAngleSin) * powf(fabs(xyAngleSin), n1);
        vertex.z = scale * signum(xyAngleCos) * powf(fabs(xyAngleCos), n1) * signum(xzAngleSin) * powf(fabs(xzAngleSin), n2);
        
            return vertex;
    }

    void SuperEllipsoidModel::storeVertexAndNormalVectorInArray(const Vec3f& vertex,
                                                                const Vec3f& normalVector,
                                                                int&         vertexIndex,
                                                                int&         normalVectorIndex,
                                                                float*       roundedCubeCoordinates,
                                                                float*       roundedCubeNormalVectors)
    {
        /* Save vertex and increment counter/index. */
        roundedCubeCoordinates[vertexIndex++] = vertex.x;
        roundedCubeCoordinates[vertexIndex++] = vertex.y;
        roundedCubeCoordinates[vertexIndex++] = vertex.z;
        roundedCubeCoordinates[vertexIndex++] = 1.0f;

        /* Save normal vector and increment counter/index. */
        roundedCubeNormalVectors[normalVectorIndex++] = normalVector.x;
        roundedCubeNormalVectors[normalVectorIndex++] = normalVector.y;
        roundedCubeNormalVectors[normalVectorIndex++] = normalVector.z;
        roundedCubeNormalVectors[normalVectorIndex++] = 1.0f;
    }
}