← Back to branch summary

~ubuntu-branches/debian/squeeze/inkscape/squeeze

« back to all changes in this revision

Viewing changes to src/proj_pt.h

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Viehmann
  • Date: 2008-09-09 23:29:02 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20080909232902-c50iujhk1w79u8e7
Tags: 0.46-2.1
http://bugs.debian.org/487623
* Non-maintainer upload.
* Add upstream patch fixing a crash in the open dialog
  in the zh_CN.utf8 locale. Closes: #487623.
  Thanks to Luca Bruno for the patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/proj_pt.h
 
1
#ifndef __PROJ_PT_H__
 
2
#define __PROJ_PT_H__
 
3
 
 
4
/*
 
5
 * 3x4 transformation matrix to map points from projective 3-space into the projective plane
 
6
 *
 
7
 * Authors:
 
8
 *   Maximilian Albert <Anhalter42@gmx.de>
 
9
 *
 
10
 * Copyright (C) 2007  Authors
 
11
 *
 
12
 * Released under GNU GPL, read the file 'COPYING' for more information
 
13
 */
 
14
 
 
15
#include "libnr/nr-point.h"
 
16
#include "libnr/nr-values.h"
 
17
#include <gtk/gtk.h>
 
18
 
 
19
namespace Proj {
 
20
 
 
21
const double epsilon = 1E-6;
 
22
 
 
23
// TODO: Catch the case when the constructors are called with only zeros
 
24
class Pt2 {
 
25
public:
 
26
    Pt2 () { pt[0] = 0; pt[1] = 0; pt[2] = 1.0; } // we default to (0 : 0 : 1)
 
27
    Pt2 (double x, double y, double w) { pt[0] = x; pt[1] = y; pt[2] = w; }
 
28
    Pt2 (NR::Point const &point) { pt[0] = point[NR::X]; pt[1] = point[NR::Y]; pt[2] = 1; }
 
29
    Pt2 (const gchar *coord_str);
 
30
 
 
31
    inline double operator[] (unsigned int index) const {
 
32
        if (index > 2) { return NR_HUGE; }
 
33
        return pt[index];
 
34
    }
 
35
    inline double &operator[] (unsigned int index) {
 
36
        // FIXME: How should we handle wrong indices?
 
37
        //if (index > 2) { return NR_HUGE; }
 
38
        return pt[index];
 
39
    }
 
40
    inline bool operator== (Pt2 &rhs) {
 
41
        normalize();
 
42
        rhs.normalize();
 
43
        return (fabs(pt[0] - rhs.pt[0]) < epsilon &&
 
44
                fabs(pt[1] - rhs.pt[1]) < epsilon &&
 
45
                fabs(pt[2] - rhs.pt[2]) < epsilon);
 
46
    }
 
47
    inline bool operator!= (Pt2 &rhs) {
 
48
        return !((*this) == rhs);
 
49
    }
 
50
 
 
51
    /*** For convenience, we define addition/subtraction etc. as "affine" operators (i.e.,
 
52
         the result for finite points is the same as if the affine points were addes ***/
 
53
    inline Pt2 &operator+(Pt2 &rhs) const {
 
54
        Pt2 *result = new Pt2 (*this);
 
55
        result->normalize();
 
56
        rhs.normalize();
 
57
        for ( unsigned i = 0 ; i < 2 ; ++i ) {
 
58
            result->pt[i] += rhs.pt[i];
 
59
        }
 
60
        return *result;
 
61
    }
 
62
 
 
63
    inline Pt2 &operator-(Pt2 &rhs) const {
 
64
        Pt2 *result = new Pt2 (*this);
 
65
        result->normalize();
 
66
        rhs.normalize();
 
67
        for ( unsigned i = 0 ; i < 2 ; ++i ) {
 
68
            result->pt[i] -= rhs.pt[i];
 
69
        }
 
70
        return *result;
 
71
    }
 
72
 
 
73
    inline Pt2 &operator*(double const s) const {
 
74
        Pt2 *result = new Pt2 (*this);
 
75
        result->normalize();
 
76
        for ( unsigned i = 0 ; i < 2 ; ++i ) {
 
77
            result->pt[i] *= s;
 
78
        }
 
79
        return *result;
 
80
    }
 
81
 
 
82
    void normalize();
 
83
    NR::Point affine();
 
84
    inline bool is_finite() { return pt[2] != 0; } // FIXME: Should we allow for some tolerance?
 
85
    gchar *coord_string();
 
86
    inline void print(gchar const *s) const { g_print ("%s(%8.2f : %8.2f : %8.2f)\n", s, pt[0], pt[1], pt[2]); }
 
87
 
 
88
private:
 
89
    double pt[3];
 
90
};
 
91
 
 
92
 
 
93
class Pt3 {
 
94
public:
 
95
    Pt3 () { pt[0] = 0; pt[1] = 0; pt[2] = 0; pt[3] = 1.0; } // we default to (0 : 0 : 0 : 1)
 
96
    Pt3 (double x, double y, double z, double w) { pt[0] = x; pt[1] = y; pt[2] = z; pt[3] = w; }
 
97
    Pt3 (const gchar *coord_str);
 
98
 
 
99
    inline bool operator== (Pt3 &rhs) {
 
100
        normalize();
 
101
        rhs.normalize();
 
102
        return (fabs(pt[0] - rhs.pt[0]) < epsilon &&
 
103
                fabs(pt[1] - rhs.pt[1]) < epsilon &&
 
104
                fabs(pt[2] - rhs.pt[2]) < epsilon &&
 
105
                fabs(pt[3] - rhs.pt[3]) < epsilon);
 
106
    }
 
107
 
 
108
    /*** For convenience, we define addition/subtraction etc. as "affine" operators (i.e.,
 
109
         the result for finite points is the same as if the affine points were addes ***/
 
110
    inline Pt3 &operator+(Pt3 &rhs) const {
 
111
        Pt3 *result = new Pt3 (*this);
 
112
        result->normalize();
 
113
        rhs.normalize();
 
114
        for ( unsigned i = 0 ; i < 3 ; ++i ) {
 
115
            result->pt[i] += rhs.pt[i];
 
116
        }
 
117
        return *result;
 
118
    }
 
119
 
 
120
    inline Pt3 &operator-(Pt3 &rhs) const {
 
121
        Pt3 *result = new Pt3 (*this);
 
122
        result->normalize();
 
123
        rhs.normalize();
 
124
        for ( unsigned i = 0 ; i < 3 ; ++i ) {
 
125
            result->pt[i] -= rhs.pt[i];
 
126
        }
 
127
        return *result;
 
128
    }
 
129
 
 
130
    inline Pt3 &operator*(double const s) const {
 
131
        Pt3 *result = new Pt3 (*this);
 
132
        result->normalize();
 
133
        for ( unsigned i = 0 ; i < 3 ; ++i ) {
 
134
            result->pt[i] *= s;
 
135
        }
 
136
        return *result;
 
137
    }
 
138
    
 
139
    inline double operator[] (unsigned int index) const {
 
140
        if (index > 3) { return NR_HUGE; }
 
141
        return pt[index];
 
142
    }
 
143
    inline double &operator[] (unsigned int index) {
 
144
        // FIXME: How should we handle wrong indices?
 
145
        //if (index > 3) { return NR_HUGE; }
 
146
        return pt[index];
 
147
    }
 
148
    void normalize();
 
149
    inline bool is_finite() { return pt[3] != 0; } // FIXME: Should we allow for some tolerance?
 
150
    gchar *coord_string();
 
151
    inline void print(gchar const *s) const {
 
152
        g_print ("%s(%8.2f : %8.2f : %8.2f : %8.2f)\n", s, pt[0], pt[1], pt[2], pt[3]);
 
153
    }
 
154
 
 
155
private:
 
156
    double pt[4];
 
157
};
 
158
 
 
159
} // namespace Proj
 
160
 
 
161
#endif /* __PROJ_PT_H__ */
 
162
 
 
163
/*
 
164
  Local Variables:
 
165
  mode:c++
 
166
  c-file-style:"stroustrup"
 
167
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 
168
  indent-tabs-mode:nil
 
169
  fill-column:99
 
170
  End:
 
171
*/
 
172
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :