HDK: HOM/HOM_Geometry.h Source File

00001 /*
00002  * PROPRIETARY INFORMATION.  This software is proprietary to
00003  * Side Effects Software Inc., and is not to be reproduced,
00004  * transmitted, or disclosed in any way without written permission.
00005  *
00006  * Produced by:
00007  *      Side Effects Software Inc
00008  *      123 Front Street West, Suite 1401
00009  *      Toronto, Ontario
00010  *      Canada   M5J 2M2
00011  *      416-504-9876
00012  *
00013  * COMMENTS:
00014  */
00015 
00016 #ifndef __HOM_Geometry_h__
00017 #define __HOM_Geometry_h__
00018 
00019 #include "HOM_API.h"
00020 #include "HOM_Defines.h"
00021 #include "HOM_Errors.h"
00022 #include "HOM_IterableList.h"
00023 #include "HOM_BoundingBox.h"
00024 #include "HOM_Attrib.h"
00025 #include <vector>
00026 #include <string>
00027 #include <boost/tuple/tuple.hpp>
00028 
00029 class HOM_Point;
00030 class HOM_Prim;
00031 class HOM_Face;
00032 class HOM_Polygon;
00033 class HOM_Surface;
00034 class HOM_Volume;
00035 class HOM_SopNode;
00036 class HOM_Vector3;
00037 class HOM_Matrix4;
00038 
00039 SWIGOUT(%rename(Geometry) HOM_Geometry;)
00040 
00041 class HOM_API HOM_Geometry
00042 {
00043 public:
00044     HOM_Geometry()
00045     { HOM_CONSTRUCT_OBJECT(this) }
00046     HOM_Geometry(const HOM_Geometry &)
00047     { HOM_CONSTRUCT_OBJECT(this) }
00048     virtual ~HOM_Geometry()
00049     { HOM_DESTRUCT_OBJECT(this) }
00050 
00051     virtual std::string __repr__() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00052 
00053     SWIGOUT(%newobject sopNode;)
00054     virtual HOM_SopNode *sopNode()
00055         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00056 
00057     SWIGOUT(%newobject freeze;)
00058     virtual HOM_Geometry *freeze() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00059 
00060     SWIGPYTHONOUT(%feature("autodoc",
00061         "iterPoints(self) -> tuple of Points") iterPoints;)
00062     SWIGOUT(%newobject iterPoints;)
00063     virtual HOM_IterableList<HOM_Point> *iterPoints()
00064         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00065 
00066     SWIGPYTHONOUT(%feature("autodoc",
00067         "points(self) -> tuple of Points") points;)
00068     virtual std::vector<HOM_ElemPtr<HOM_Point> > points()
00069         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00070 
00071     SWIGPYTHONOUT(%feature("autodoc",
00072         "iterPrims(self) -> tuple of Prims") iterPrims;)
00073     SWIGOUT(%newobject iterPrims;)
00074     virtual HOM_IterableList<HOM_Prim> *iterPrims()
00075         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00076 
00077     SWIGPYTHONOUT(%feature("autodoc",
00078         "prims(self) -> tuple of Prims") prims;)
00079     virtual std::vector<HOM_ElemPtr<HOM_Prim> > prims()
00080         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00081 
00082 
00083     SWIGPYTHONOUT(%feature("autodoc",
00084         "globPoints(self, pattern) -> tuple of Points") globPoints;)
00085     virtual std::vector<HOM_ElemPtr<HOM_Point> > globPoints(const char *pattern)
00086         throw(HOM_OperationFailed, HOM_TypeError, HOM_ObjectWasDeleted,
00087             HOM_Error) = 0;
00088 
00089     SWIGPYTHONOUT(%feature("autodoc",
00090         "globPrims(self, pattern) -> tuple of Prims") globPrims;)
00091     virtual std::vector<HOM_ElemPtr<HOM_Prim> > globPrims(const char *pattern)
00092         throw(HOM_OperationFailed, HOM_TypeError, HOM_ObjectWasDeleted,
00093             HOM_Error) = 0;
00094 
00095 
00096     SWIGPYTHONOUT(%feature("autodoc",
00097         "pointAttribs(self) -> tuple of Attribs") pointAttribs;)
00098     virtual std::vector<HOM_ElemPtr<HOM_Attrib> > pointAttribs()
00099         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00100 
00101     SWIGPYTHONOUT(%feature("autodoc",
00102         "primAttribs(self) -> tuple of Attribs") primAttribs;)
00103     virtual std::vector<HOM_ElemPtr<HOM_Attrib> > primAttribs()
00104         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00105 
00106     SWIGPYTHONOUT(%feature("autodoc",
00107         "vertexAttribs(self) -> tuple of Attribs") vertexAttribs;)
00108     virtual std::vector<HOM_ElemPtr<HOM_Attrib> > vertexAttribs()
00109         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00110 
00111     SWIGPYTHONOUT(%feature("autodoc",
00112         "globalAttribs(self) -> tuple of Attribs") globalAttribs;)
00113     virtual std::vector<HOM_ElemPtr<HOM_Attrib> > globalAttribs()
00114         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00115 
00116 
00117     SWIGPYTHONOUT(%feature("autodoc",
00118         "findPointAttrib(self, name) -> Attrib or None") findPointAttrib;)
00119     SWIGOUT(%newobject findPointAttrib;)
00120     virtual HOM_Attrib *findPointAttrib(const char *name)
00121         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00122 
00123     SWIGPYTHONOUT(%feature("autodoc",
00124         "findPrimAttrib(self, name) -> Attrib or None") findPrimAttrib;)
00125     SWIGOUT(%newobject findPrimAttrib;)
00126     virtual HOM_Attrib *findPrimAttrib(const char *name)
00127         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00128 
00129     SWIGPYTHONOUT(%feature("autodoc",
00130         "findVertexAttrib(self, name) -> Attrib or None") findVertexAttrib;)
00131     SWIGOUT(%newobject findVertexAttrib;)
00132     virtual HOM_Attrib *findVertexAttrib(const char *name)
00133         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00134 
00135     SWIGPYTHONOUT(%feature("autodoc",
00136         "findGlobalAttrib(self, name) -> Attrib or None") findGlobalAttrib;)
00137     SWIGOUT(%newobject findGlobalAttrib;)
00138     virtual HOM_Attrib *findGlobalAttrib(const char *name)
00139         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00140 
00141     SWIGPYTHONOUT(%feature("autodoc",
00142         "attribType(self) -> hou.attribType enum value") attribType;)
00143     virtual HOM_EnumValue& attribType() throw(HOM_Error) = 0;
00144 
00145 
00146     // These methods return global (detail) attribute values.
00147     virtual float floatAttribValue(const char *name)
00148         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00149 
00150     virtual float floatAttribValue(HOM_Attrib &attrib)
00151         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00152 
00153     SWIGPYTHONOUT(%feature("autodoc",
00154         "floatListAttribValue(self, name) -> tuple of floats")
00155         floatListAttribValue(const char *);)
00156     virtual std::vector<float> floatListAttribValue(const char *name)
00157         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00158 
00159     SWIGPYTHONOUT(%feature("autodoc",
00160         "floatListAttribValue(self, attrib) -> tuple of floats")
00161         floatListAttribValue(HOM_Attrib &);)
00162     virtual std::vector<float> floatListAttribValue(HOM_Attrib &attrib)
00163         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00164 
00165     virtual int intAttribValue(const char *name)
00166         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00167 
00168     virtual int intAttribValue(HOM_Attrib &attrib)
00169         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00170 
00171     SWIGPYTHONOUT(%feature("autodoc",
00172         "intListAttribValue(self, name) -> tuple of ints")
00173         intListAttribValue(const char *);)
00174     virtual std::vector<int> intListAttribValue(const char *name)
00175         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00176 
00177     SWIGPYTHONOUT(%feature("autodoc",
00178         "intListAttribValue(self, attrib) -> tuple of ints")
00179         intListAttribValue(HOM_Attrib &);)
00180     virtual std::vector<int> intListAttribValue(HOM_Attrib &attrib)
00181         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00182 
00183     virtual std::string stringAttribValue(const char *name)
00184         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00185 
00186     virtual std::string stringAttribValue(HOM_Attrib &attrib)
00187         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00188 
00189 
00190 
00191     // These methods return/set arrays of point/primitive attribute values.
00192     virtual std::vector<float> pointFloatAttribValues(const char *name)
00193         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00194     virtual std::string pointFloatAttribValuesAsString(const char *name)
00195         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00196     virtual std::vector<float> primFloatAttribValues(const char *name)
00197         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00198     virtual std::string primFloatAttribValuesAsString(const char *name)
00199         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00200 
00201 
00202     // Methods that modify geometry:
00203 
00204     virtual void setPointFloatAttribValues(
00205             const char *name, const std::vector<float> &values)
00206         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00207             HOM_ObjectWasDeleted, HOM_Error) = 0;
00208     virtual void setPointFloatAttribValuesFromString(
00209             const char *name, const std::string &values)
00210         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00211             HOM_ObjectWasDeleted, HOM_Error) = 0;
00212     virtual void setPrimFloatAttribValues(
00213             const char *name, const std::vector<float> &values)
00214         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00215             HOM_ObjectWasDeleted, HOM_Error) = 0;
00216     virtual void setPrimFloatAttribValuesFromString(
00217             const char *name, const std::string &values)
00218         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00219             HOM_ObjectWasDeleted, HOM_Error) = 0;
00220 
00221     SWIGOUT(%newobject createPoint;)
00222     virtual HOM_Point *createPoint()
00223         throw(HOM_GeometryPermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00224 
00225     SWIGOUT(%newobject createPolygon;)
00226     virtual HOM_Polygon *createPolygon()
00227         throw(HOM_GeometryPermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00228 
00229     SWIGOUT(%newobject createNURBSCurve;)
00230     SWIGOUT(%kwargs createNURBSCurve;)
00231     virtual HOM_Face *createNURBSCurve(int num_points, bool is_closed=false)
00232         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00233             HOM_ObjectWasDeleted, HOM_Error) = 0;
00234 
00235     SWIGOUT(%newobject createBezierCurve;)
00236     SWIGOUT(%kwargs createBezierCurve;)
00237     virtual HOM_Face *createBezierCurve(int num_points, bool is_closed=false)
00238         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00239             HOM_ObjectWasDeleted, HOM_Error) = 0;
00240 
00241     SWIGOUT(%newobject createNURBSSurface;)
00242     SWIGOUT(%kwargs createNURBSSurface;)
00243     virtual HOM_Surface *createNURBSSurface(
00244             int rows, int cols,
00245             bool is_closed_in_u=false, bool is_closed_in_v=false)
00246         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00247             HOM_ObjectWasDeleted, HOM_Error) = 0;
00248 
00249     SWIGOUT(%newobject createBezierSurface;)
00250     SWIGOUT(%kwargs createBezierSurface;)
00251     virtual HOM_Surface *createBezierSurface(
00252             int rows, int cols,
00253             bool is_closed_in_u=false, bool is_closed_in_v=false)
00254         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00255             HOM_ObjectWasDeleted, HOM_Error) = 0;
00256 
00257     SWIGOUT(%newobject createMeshSurface;)
00258     SWIGOUT(%kwargs createMeshSurface;)
00259     virtual HOM_Surface *createMeshSurface(
00260             int rows, int cols,
00261             bool is_closed_in_u=false, bool is_closed_in_v=false)
00262         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00263             HOM_ObjectWasDeleted, HOM_Error) = 0;
00264 
00265     SWIGOUT(%newobject createVolume;)
00266     SWIGOUT(%kwargs createVolume;)
00267     virtual HOM_Volume *createVolume(
00268             int xres, int yres, int zres, HOM_BoundingBox *bounding_box=NULL)
00269         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00270             HOM_ObjectWasDeleted, HOM_Error) = 0;
00271 
00272 
00273     virtual void transform(HOM_Matrix4 &matrix)
00274         throw(HOM_GeometryPermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00275 
00276     virtual void transformPrims(
00277             const std::vector<HOM_Prim *> &prims, HOM_Matrix4 &matrix)
00278         throw(HOM_GeometryPermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00279 
00280     virtual void deletePrims(
00281             const std::vector<HOM_Prim *> &prims, bool keep_points = false)
00282         throw(HOM_GeometryPermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00283 
00284     virtual void deletePoints(const std::vector<HOM_Point *> &points)
00285         throw(HOM_GeometryPermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00286 
00287     virtual void merge(HOM_Geometry& geo_in)
00288         throw(HOM_GeometryPermissionError, HOM_ObjectWasDeleted, HOM_Error) = 0;
00289 
00290     virtual HOM_Attrib *addAttrib(
00291             HOM_EnumValue &type, const char *name, int default_value)
00292         throw(HOM_GeometryPermissionError, HOM_TypeError,
00293             HOM_ObjectWasDeleted, HOM_Error) = 0;
00294 
00295     virtual HOM_Attrib *addAttrib(
00296             HOM_EnumValue &type, const char *name, float default_value)
00297         throw(HOM_GeometryPermissionError, HOM_TypeError,
00298             HOM_ObjectWasDeleted, HOM_Error) = 0;
00299 
00300     virtual HOM_Attrib *addAttrib(
00301             HOM_EnumValue &type, const char *name, const char *default_value)
00302         throw(HOM_GeometryPermissionError, HOM_TypeError,
00303             HOM_ObjectWasDeleted, HOM_Error) = 0;
00304 
00305     virtual HOM_Attrib *addAttrib(
00306             HOM_EnumValue &type,
00307             const char *name,
00308             const std::vector<int> &default_value)
00309         throw(HOM_GeometryPermissionError, HOM_TypeError,
00310             HOM_ObjectWasDeleted, HOM_Error) = 0;
00311 
00312     virtual HOM_Attrib *addAttrib(
00313             HOM_EnumValue &type,
00314             const char *name,
00315             const std::vector<float> &default_value,
00316             bool transform_as_normal=false)
00317         throw(HOM_GeometryPermissionError, HOM_TypeError,
00318             HOM_ObjectWasDeleted, HOM_Error) = 0;
00319 
00320 
00321     virtual void setGlobalAttribValue(
00322             HOM_Attrib &attrib, int attrib_value)
00323         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00324             HOM_ObjectWasDeleted, HOM_Error) = 0;
00325     virtual void setGlobalAttribValue(
00326             HOM_Attrib &attrib, float attrib_value)
00327         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00328             HOM_ObjectWasDeleted, HOM_Error) = 0;
00329     virtual void setGlobalAttribValue(
00330             HOM_Attrib &attrib, const char *attrib_value)
00331         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00332             HOM_ObjectWasDeleted, HOM_Error) = 0;
00333     virtual void setGlobalAttribValue(
00334             HOM_Attrib &attrib, const std::vector<int> &attrib_value)
00335         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00336             HOM_ObjectWasDeleted, HOM_Error) = 0;
00337     virtual void setGlobalAttribValue(
00338             HOM_Attrib &attrib, const std::vector<float> &attrib_value)
00339         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00340             HOM_ObjectWasDeleted, HOM_Error) = 0;
00341 
00342     virtual void setGlobalAttribValue(
00343             const char *attrib_name, int attrib_value)
00344         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00345             HOM_ObjectWasDeleted, HOM_Error) = 0;
00346     virtual void setGlobalAttribValue(
00347             const char *attrib_name, float attrib_value)
00348         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00349             HOM_ObjectWasDeleted, HOM_Error) = 0;
00350     virtual void setGlobalAttribValue(
00351             const char *attrib_name, const char *attrib_value)
00352         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00353             HOM_ObjectWasDeleted, HOM_Error) = 0;
00354     // Note that, because of strangess the with way swig works when deciding
00355     // which overloaded method to call, it's very important that we list the
00356     // vector of ints before the vector of floats.  Otherwise, swig will call
00357     // the float version when you pass in a vector of ints.
00358     virtual void setGlobalAttribValue(
00359             const char *attrib_name, const std::vector<int> &attrib_value)
00360         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00361             HOM_ObjectWasDeleted, HOM_Error) = 0;
00362     virtual void setGlobalAttribValue(
00363             const char *attrib_name, const std::vector<float> &attrib_value)
00364         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00365             HOM_ObjectWasDeleted, HOM_Error) = 0;
00366 
00367 #ifdef SWIG
00368 %extend
00369 {
00370     SWIGPYTHONOUT(%feature("autodoc",
00371         "attribValue(self, name) -> int, float, string, or tuple")
00372         attribValue(const char *);)
00373     InterpreterObject attribValue(const char *name)
00374         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
00375     { return HOMattribValue(*self, name); }
00376 
00377     SWIGPYTHONOUT(%feature("autodoc",
00378         "attribValue(self, attrib) -> int, float, string, or tuple")
00379         attribValue(HOM_Attrib &);)
00380     InterpreterObject attribValue(HOM_Attrib &attrib)
00381         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
00382     { return HOMattribValue(*self, attrib); }
00383 }
00384 #endif
00385 
00386     virtual void saveToFile(const char *file_name)
00387         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00388 
00389     virtual HOM_BoundingBox boundingBox()
00390         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00391 
00392     virtual boost::tuple<HOM_ElemPtr<HOM_Prim>, float, float, float>
00393         nearestPrim(const std::vector<float> &position)
00394         throw(HOM_InvalidSize, HOM_ObjectWasDeleted, HOM_Error) = 0;
00395 };
00396 
00397 #endif