HOM/HOM_hmath.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * COMMENTS:
 *      This "submodule" is named hou.hmath instead of hou.math to prevent
 *      conflicts with the python math module, since expression evaluation
 *      contexts have run from hou import *.
 */

#ifndef __HOM_hmath_h__
#define __HOM_hmath_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_Errors.h"
#include <SYS/SYS_Math.h>
#include <vector>
#include <map>
class HOM_Matrix4;
class HOM_Vector3;

SWIGOUT(%rename(hmath) HOM_hmath;)

class HOM_API HOM_hmath
{
public:
    virtual ~HOM_hmath()
    {}

    virtual std::string __repr__() throw(HOM_Error) = 0;

    SWIGOUT(%newobject identityTransform;)
    virtual HOM_Matrix4 *identityTransform() = 0;

    SWIGOUT(%newobject buildTranslate;)
    virtual HOM_Matrix4 *buildTranslate(double tx, double ty, double tz) = 0;
    virtual HOM_Matrix4 *buildTranslate(const std::vector<double> &values) = 0;
    virtual HOM_Matrix4 *buildTranslate(HOM_Vector3 &values) = 0;

    SWIGOUT(%newobject buildScale;)
    virtual HOM_Matrix4 *buildScale(double sx, double sy, double sz) = 0;
    virtual HOM_Matrix4 *buildScale(const std::vector<double> &values)
        throw(HOM_ValueError, HOM_Error) = 0;
    virtual HOM_Matrix4 *buildScale(HOM_Vector3 &values) = 0;

    SWIGOUT(%newobject buildShear;)
    virtual HOM_Matrix4 *buildShear(double sxy, double sxz, double syz) = 0;
    virtual HOM_Matrix4 *buildShear(const std::vector<double> &values)
        throw(HOM_ValueError, HOM_Error) = 0;
    virtual HOM_Matrix4 *buildShear(HOM_Vector3 &values) = 0;

    SWIGOUT(%newobject buildRotate;)
    virtual HOM_Matrix4 *buildRotate(
            double rx, double ry, double rz, const char *order="xyz")
        throw(HOM_ValueError, HOM_Error) = 0;
    virtual HOM_Matrix4 *buildRotate(
            const std::vector<double> &values, const char *order="xyz")
        throw(HOM_ValueError, HOM_Error) = 0;
    virtual HOM_Matrix4 *buildRotate(
            HOM_Vector3 &values, const char *order="xyz")
        throw(HOM_ValueError, HOM_Error) = 0;

    SWIGOUT(%newobject buildRotateAboutAxis;)
    virtual HOM_Matrix4 *buildRotateAboutAxis(
            const std::vector<double> &axis, double angle_in_deg)
        throw(HOM_ValueError, HOM_Error)= 0;
    virtual HOM_Matrix4 *buildRotateAboutAxis(
        HOM_Vector3 &axis, double angle_in_deg) = 0;

    virtual HOM_Matrix4* buildTransform(
            const std::map<std::string, std::vector<double> > &values_dict,
            const char *transform_order="srt",
            const char *rotate_order="xyz")
        throw(HOM_ValueError, HOM_TypeError, HOM_Error) = 0;


    virtual double degToRad(double degrees) = 0;
    virtual double radToDeg(double radians) = 0;

    SWIGPYTHONOUT(%feature("autodoc",
        "noise1d(self, pos) -> float") noise1d;)
    virtual double noise1d(const std::vector<double> &pos) const = 0;

    SWIGPYTHONOUT(%feature("autodoc",
        "noise3d(self, pos) -> Vector3") noise3d;)
    virtual HOM_Vector3 noise3d(const std::vector<double> &pos) const = 0;

    SWIGPYTHONOUT(%feature("autodoc",
        "fit(self, value, oldmin, oldmax, newmin, newmax) -> float") fit;)
    double fit(
        double value, double oldmin, double oldmax,
        double newmin, double newmax)
    { return SYSfit(value, oldmin, oldmax, newmin, newmax); }

    SWIGPYTHONOUT(%feature("autodoc",
        "fit01(self, value, newmin, newmax) -> float") fit01;)
    double fit01(double value, double newmin, double newmax)
    { return SYSfit(value, 0, 1, newmin, newmax); }

    SWIGPYTHONOUT(%feature("autodoc",
        "fit10(self, value, newmin, newmax) -> float") fit10;)
    double fit10(double value, double newmin, double newmax)
    { return SYSfit(value, 1, 0, newmin, newmax); }

    SWIGPYTHONOUT(%feature("autodoc",
        "fit11(self, value, newmin, newmax) -> float") fit11;)
    double fit11(double value, double newmin, double newmax)
    { return SYSfit(value, -1, 1, newmin, newmax); }

    SWIGPYTHONOUT(%feature("autodoc", "sign(self, value) -> float") sign;)
    double sign(double value)
    { return value < 0 ? -1 : (value > 0); }

    SWIGPYTHONOUT(%feature("autodoc",
        "clamp(self, value, min, max) -> float") clamp;)
    double clamp(double value, double min, double max)
    { return SYSclamp(value, min, max); }

    SWIGPYTHONOUT(%feature("autodoc",
        "smooth(self, value, min, max) -> float") smooth;)
    double smooth(double value, double min, double max)
    {
        // Caution, the order of the arguments is switched around here
        return SYSsmooth(min, max, value);
    }

    SWIGPYTHONOUT(%feature("autodoc",
        "wrap(self, value, min, max) -> float") wrap;)
    virtual double wrap(double value, double min, double max) const = 0;

    SWIGPYTHONOUT(%feature("autodoc",
        "rand(self, seed) -> float") rand;)
    virtual double rand(double seed) const = 0;
};

#endif

---