Main Page | File List

rt_vectors.h

00001 /*
00002  *  rt_vectors.h - contains 2- and 3-vector classes
00003  *
00004  *
00005  *  Created by Sriram Vaidhyanathan on Thu Feb 26 2004.
00006  *  15-462 Computer Graphics Spring 2004 Programming Assignment 3
00007  *
00008  */
00009 
00010 #ifndef _RT_VECTORS_H_
00011 #define _RT_VECTORS_H_
00012 
00013 #include <iostream>
00014 using namespace std;
00015 
00016 #include <stdlib.h>
00017 #include <stdio.h>
00018 #include <math.h>
00019 #include <assert.h>
00020 
00021 /* Class for 2-vector */
00022 class Vec2f
00023 {
00024 
00025 public:
00026 
00027     /* Data members */
00028     float data[2];
00029 
00030 
00031     /* Constructor */
00032     Vec2f() { data[0] = data[1] = 0; }
00033 
00034     /* Constructor */
00035     Vec2f(const Vec2f &V) {
00036         data[0] = V.data[0];
00037         data[1] = V.data[1];
00038     }
00039 
00040     /* Constructor */
00041     Vec2f(float d0, float d1) {
00042         data[0] = d0;
00043         data[1] = d1;
00044     }
00045 
00046     /* Constructor */
00047     Vec2f(const Vec2f &V1, const Vec2f &V2) {
00048         data[0] = V1.data[0] - V2.data[0];
00049         data[1] = V1.data[1] - V2.data[1];
00050     }
00051 
00052     /* Destructor */
00053     ~Vec2f() { }
00054 
00055     /* Access data members */
00056     void Get(float &d0, float &d1) const {
00057         d0 = data[0];
00058         d1 = data[1];
00059     }
00060 
00061     /* Operator overload */
00062     float operator[](int i) const {
00063         assert (i >= 0 && i < 2);
00064         return data[i];
00065     }
00066 
00067     /* Grab data members */
00068     float x() const { return data[0]; }
00069     float y() const { return data[1]; }
00070 
00071     /* figure out the length of the vector */
00072     float Length() const {
00073         float l = (float)sqrt( data[0] * data[0] + data[1] * data[1] );
00074         return l;
00075     }
00076 
00077     /* Set data members */
00078     void Set(float d0, float d1) {
00079         data[0] = d0;
00080         data[1] = d1;
00081     }
00082 
00083     /* Scale the vector */
00084     void Scale(float d0, float d1) {
00085         data[0] *= d0;
00086         data[1] *= d1;
00087     }
00088 
00089     /* Divide the vector */
00090     void Divide(float d0, float d1) {
00091         data[0] /= d0;
00092         data[1] /= d1;
00093     }
00094 
00095     /* Flip signs */
00096     void Negate() {
00097         data[0] = -data[0];
00098         data[1] = -data[1];
00099     }
00100 
00101     /* Operator overload */
00102     Vec2f& operator=(const Vec2f &V) {
00103         data[0] = V.data[0];
00104         data[1] = V.data[1];
00105         return *this;
00106     }
00107 
00108     /* Operator overload */
00109     int operator==(const Vec2f &V) const {
00110         return ((data[0] == V.data[0]) &&
00111                 (data[1] == V.data[1]));
00112     }
00113 
00114     /* Operator overload */
00115     int operator!=(const Vec2f &V) {
00116         return ((data[0] != V.data[0]) ||
00117                 (data[1] != V.data[1]));
00118     }
00119 
00120     /* Operator overload */
00121     Vec2f& operator+=(const Vec2f &V) {
00122         data[0] += V.data[0];
00123         data[1] += V.data[1];
00124         return *this;
00125     }
00126 
00127     /* Operator overload */
00128     Vec2f& operator-=(const Vec2f &V) {
00129         data[0] -= V.data[0];
00130         data[1] -= V.data[1];
00131         return *this;
00132     }
00133 
00134     /* Operator overload */
00135     Vec2f& operator*=(float f) {
00136         data[0] *= f;
00137         data[1] *= f;
00138         return *this;
00139     }
00140 
00141     /* Operator overload */
00142     Vec2f& operator/=(float f) {
00143         data[0] /= f;
00144         data[1] /= f;
00145         return *this;
00146     }
00147 
00148     /* Compute dot product */
00149     float Dot2(const Vec2f &V) const {
00150         return data[0] * V.data[0] + data[1] * V.data[1] ;
00151     }
00152 
00153     /* Add vectors */
00154     static void Add(Vec2f &a, const Vec2f &b, const Vec2f &c ) {
00155         a.data[0] = b.data[0] + c.data[0];
00156         a.data[1] = b.data[1] + c.data[1];
00157     }
00158 
00159     /* Subtract vectors */
00160     static void Sub(Vec2f &a, const Vec2f &b, const Vec2f &c ) {
00161         a.data[0] = b.data[0] - c.data[0];
00162         a.data[1] = b.data[1] - c.data[1];
00163     }
00164 
00165     /* Copy and scale vectors */
00166     static void CopyScale(Vec2f &a, const Vec2f &b, float c ) {
00167         a.data[0] = b.data[0] * c;
00168         a.data[1] = b.data[1] * c;
00169     }
00170 
00171     /* Add and scale vectors */
00172     static void AddScale(Vec2f &a, const Vec2f &b, const Vec2f &c, float d ) {
00173         a.data[0] = b.data[0] + c.data[0] * d;
00174         a.data[1] = b.data[1] + c.data[1] * d;
00175     }
00176 
00177     /* Average out vectors */
00178     static void Average(Vec2f &a, const Vec2f &b, const Vec2f &c ) {
00179         a.data[0] = (b.data[0] + c.data[0]) * 0.5f;
00180         a.data[1] = (b.data[1] + c.data[1]) * 0.5f;
00181     }
00182 
00183     /* Take weighted sum for vectors */
00184     static void WeightedSum(Vec2f &a, const Vec2f &b, float c, const Vec2f &d, float e ) {
00185         a.data[0] = b.data[0] * c + d.data[0] * e;
00186         a.data[1] = b.data[1] * c + d.data[1] * e;
00187     }
00188 
00189     /* Write out to stdout */
00190     void Write(FILE *F = stdout) {
00191         fprintf (F, "%f %f\n",data[0],data[1]);
00192     }
00193 };
00194 
00195 /* Class for 3-vectors */
00196 class Vec3f
00197 {
00198     
00199 public:
00200 
00201     /* Data members */
00202     float data[3];
00203 
00204 
00205     /* Constructor */
00206     Vec3f() { data[0] = data[1] = data[2] = 0; }
00207 
00208     /* Constructor */
00209     Vec3f(const Vec3f &V) {
00210         data[0] = V.data[0];
00211         data[1] = V.data[1];
00212         data[2] = V.data[2]; }
00213 
00214     /* Constructor */
00215     Vec3f(float d0, float d1, float d2) {
00216         data[0] = d0;
00217         data[1] = d1;
00218         data[2] = d2; }
00219 
00220     /* Constructor */
00221     Vec3f(const Vec3f &V1, const Vec3f &V2) {
00222         data[0] = V1.data[0] - V2.data[0];
00223         data[1] = V1.data[1] - V2.data[1];
00224         data[2] = V1.data[2] - V2.data[2]; }
00225 
00226     /* Destructor */
00227     ~Vec3f() { }
00228 
00229     /* Access data members */
00230     void Get(float &d0, float &d1, float &d2) const {
00231         d0 = data[0];
00232         d1 = data[1];
00233         d2 = data[2];
00234     }
00235 
00236     /* Operator overload */
00237     float operator[](int i) const {
00238         assert (i >= 0 && i < 3);
00239         return data[i];
00240     }
00241 
00242     /* Grab data members */
00243     float x() const { return data[0]; }
00244     float y() const { return data[1]; }
00245     float z() const { return data[2]; }
00246     float r() const { return data[0]; }
00247     float g() const { return data[1]; }
00248     float b() const { return data[2]; }
00249 
00250     /* Compute length of vector */
00251     float Length() const {
00252         float l = (float)sqrt( data[0] * data[0] +
00253                                data[1] * data[1] +
00254                                data[2] * data[2] );
00255         return l;
00256     }
00257 
00258     /* Set vectors */
00259     void Set(float d0, float d1, float d2) {
00260         data[0] = d0;
00261         data[1] = d1;
00262         data[2] = d2;
00263     }
00264 
00265     /* Scale vector */
00266     void Scale(float d0, float d1, float d2) {
00267         data[0] *= d0;
00268         data[1] *= d1;
00269         data[2] *= d2;
00270     }
00271 
00272     /* Divide vector */
00273     void Divide(float d0, float d1, float d2) {
00274         data[0] /= d0;
00275         data[1] /= d1;
00276         data[2] /= d2;
00277     }
00278 
00279     /* Normalize vector */
00280     void Normalize() {
00281         float l = Length();
00282         if (l > 0) {
00283             data[0] /= l;
00284             data[1] /= l;
00285             data[2] /= l;
00286         }
00287     }
00288 
00289     /* Negate vector */
00290     void Negate() {
00291         data[0] = -data[0];
00292         data[1] = -data[1];
00293         data[2] = -data[2];
00294     }
00295 
00296     /* Operator overload */
00297     Vec3f& operator=(const Vec3f &V) {
00298         data[0] = V.data[0];
00299         data[1] = V.data[1];
00300         data[2] = V.data[2];
00301         return *this;
00302     }
00303 
00304     /* Operator overload */
00305     int operator==(const Vec3f &V) {
00306         return ((data[0] == V.data[0]) &&
00307                 (data[1] == V.data[1]) &&
00308                 (data[2] == V.data[2]));
00309     }
00310 
00311     /* Operator overload */
00312     int operator!=(const Vec3f &V) {
00313         return ((data[0] != V.data[0]) ||
00314                 (data[1] != V.data[1]) ||
00315                 (data[2] != V.data[2]));
00316     }
00317 
00318     /* Operator overload */
00319     Vec3f& operator+=(const Vec3f &V) {
00320         data[0] += V.data[0];
00321         data[1] += V.data[1];
00322         data[2] += V.data[2];
00323         return *this;
00324     }
00325 
00326     /* Operator overload */
00327     Vec3f& operator-=(const Vec3f &V) {
00328         data[0] -= V.data[0];
00329         data[1] -= V.data[1];
00330         data[2] -= V.data[2];
00331         return *this;
00332     }
00333 
00334     /* Operator overload */
00335     Vec3f& operator*=(int i) {
00336         data[0] = float(data[0] * i);
00337         data[1] = float(data[1] * i);
00338         data[2] = float(data[2] * i);
00339         return *this;
00340     }
00341 
00342     /* Operator overload */
00343     Vec3f& operator*=(float f) {
00344         data[0] *= f;
00345         data[1] *= f;
00346         data[2] *= f;
00347         return *this;
00348     }
00349 
00350     /* Operator overload */
00351     Vec3f& operator/=(int i) {
00352         data[0] = float(data[0] / i);
00353         data[1] = float(data[1] / i);
00354         data[2] = float(data[2] / i);
00355         return *this;
00356     }
00357 
00358     /* Operator overload */
00359     Vec3f& operator/=(float f) {
00360         data[0] /= f;
00361         data[1] /= f;
00362         data[2] /= f;
00363         return *this;
00364     }
00365 
00366     /* Operator overload */
00367     friend Vec3f operator+(const Vec3f &v1, const Vec3f &v2) {
00368         Vec3f v3; Add(v3,v1,v2); return v3;
00369     }
00370 
00371     /* Operator overload */
00372     friend Vec3f operator-(const Vec3f &v1, const Vec3f &v2) {
00373         Vec3f v3; Sub(v3,v1,v2); return v3;
00374     }
00375 
00376     /* Operator overload */
00377     friend Vec3f operator*(const Vec3f &v1, float f) {
00378         Vec3f v2; CopyScale(v2,v1,f); return v2;
00379     }
00380 
00381     /* Compute dot product */
00382     float Dot3(const Vec3f &V) const {
00383         return data[0] * V.data[0] +
00384         data[1] * V.data[1] +
00385         data[2] * V.data[2] ;
00386     }
00387 
00388     /* Add vectors */
00389     friend void Add(Vec3f &a, const Vec3f &b, const Vec3f &c ) {
00390         a.data[0] = b.data[0] + c.data[0];
00391         a.data[1] = b.data[1] + c.data[1];
00392         a.data[2] = b.data[2] + c.data[2];
00393     }
00394 
00395     /* Subtract vectors */
00396     friend void Sub(Vec3f &a, const Vec3f &b, const Vec3f &c ) {
00397         a.data[0] = b.data[0] - c.data[0];
00398         a.data[1] = b.data[1] - c.data[1];
00399         a.data[2] = b.data[2] - c.data[2];
00400     }
00401 
00402     /* Copy and scale vectors */
00403     friend void CopyScale(Vec3f &a, const Vec3f &b, float c ) {
00404         a.data[0] = b.data[0] * c;
00405         a.data[1] = b.data[1] * c;
00406         a.data[2] = b.data[2] * c;
00407     }
00408 
00409     /* Add and scale vectors */
00410     friend void AddScale(Vec3f &a, const Vec3f &b, const Vec3f &c, float d ) {
00411         a.data[0] = b.data[0] + c.data[0] * d;
00412         a.data[1] = b.data[1] + c.data[1] * d;
00413         a.data[2] = b.data[2] + c.data[2] * d;
00414     }
00415 
00416     /* Average out vectors */
00417     friend void Average(Vec3f &a, const Vec3f &b, const Vec3f &c ) {
00418         a.data[0] = (b.data[0] + c.data[0]) * 0.5f;
00419         a.data[1] = (b.data[1] + c.data[1]) * 0.5f;
00420         a.data[2] = (b.data[2] + c.data[2]) * 0.5f;
00421     }
00422 
00423     /* Take weighted sum of vectors */
00424     friend void WeightedSum(Vec3f &a, const Vec3f &b, float c, const Vec3f &d, float e ) {
00425         a.data[0] = b.data[0] * c + d.data[0] * e;
00426         a.data[1] = b.data[1] * c + d.data[1] * e;
00427         a.data[2] = b.data[2] * c + d.data[2] * e;
00428     }
00429 
00430     /* Compute cross product for vectors */
00431     static void Cross3(Vec3f &c, const Vec3f &v1, const Vec3f &v2) {
00432         float x = v1.data[1]*v2.data[2] - v1.data[2]*v2.data[1];
00433         float y = v1.data[2]*v2.data[0] - v1.data[0]*v2.data[2];
00434         float z = v1.data[0]*v2.data[1] - v1.data[1]*v2.data[0];
00435         c.data[0] = x; c.data[1] = y; c.data[2] = z;
00436     }
00437 
00438     /* Write out to stdout */
00439     void Write(FILE *F = stdout) {
00440         fprintf (F, "%f %f %f\n",data[0],data[1],data[2]);
00441     }
00442 };
00443 
00444 /* Operator overload - helpful to print out vectors */
00445 inline ostream &operator<<(ostream &os, const Vec3f &v) {
00446     os << "Vec3f <" <<v.x()<<", "<<v.y()<<", "<<v.z()<<">";
00447     return os;
00448 }
00449 
00450 typedef Vec3f Color3;
00451 
00452 #endif

Generated on Mon Oct 25 15:46:39 2004 for Graphics Project 2 by doxygen 1.3.6