00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef IPOINTS_H
00021 #define IPOINTS_H
00022
00023 #include <math.h>
00024
00025
00026
00027
00028
00029
00030
00031 inline ICOORD
00032 operator! (
00033 const ICOORD & src
00034 ) {
00035 ICOORD result;
00036
00037 result.xcoord = -src.ycoord;
00038 result.ycoord = src.xcoord;
00039 return result;
00040 }
00041
00042
00043
00044
00045
00046
00047
00048
00049 inline ICOORD
00050 operator- (
00051 const ICOORD & src
00052 ) {
00053 ICOORD result;
00054
00055 result.xcoord = -src.xcoord;
00056 result.ycoord = -src.ycoord;
00057 return result;
00058 }
00059
00060
00061
00062
00063
00064
00065
00066
00067 inline ICOORD
00068 operator+ (
00069 const ICOORD & op1,
00070 const ICOORD & op2) {
00071 ICOORD sum;
00072
00073 sum.xcoord = op1.xcoord + op2.xcoord;
00074 sum.ycoord = op1.ycoord + op2.ycoord;
00075 return sum;
00076 }
00077
00078
00079
00080
00081
00082
00083
00084
00085 inline ICOORD &
00086 operator+= (
00087 ICOORD & op1,
00088 const ICOORD & op2) {
00089 op1.xcoord += op2.xcoord;
00090 op1.ycoord += op2.ycoord;
00091 return op1;
00092 }
00093
00094
00095
00096
00097
00098
00099
00100
00101 inline ICOORD
00102 operator- (
00103 const ICOORD & op1,
00104 const ICOORD & op2) {
00105 ICOORD sum;
00106
00107 sum.xcoord = op1.xcoord - op2.xcoord;
00108 sum.ycoord = op1.ycoord - op2.ycoord;
00109 return sum;
00110 }
00111
00112
00113
00114
00115
00116
00117
00118
00119 inline ICOORD &
00120 operator-= (
00121 ICOORD & op1,
00122 const ICOORD & op2) {
00123 op1.xcoord -= op2.xcoord;
00124 op1.ycoord -= op2.ycoord;
00125 return op1;
00126 }
00127
00128
00129
00130
00131
00132
00133
00134
00135 inline inT32
00136 operator% (
00137 const ICOORD & op1,
00138 const ICOORD & op2) {
00139 return op1.xcoord * op2.xcoord + op1.ycoord * op2.ycoord;
00140 }
00141
00142
00143
00144
00145
00146
00147
00148
00149 inline inT32 operator *(
00150 const ICOORD &op1,
00151 const ICOORD &op2) {
00152 return op1.xcoord * op2.ycoord - op1.ycoord * op2.xcoord;
00153 }
00154
00155
00156
00157
00158
00159
00160
00161
00162 inline ICOORD operator *(
00163 const ICOORD &op1,
00164 inT16 scale) {
00165 ICOORD result;
00166
00167 result.xcoord = op1.xcoord * scale;
00168 result.ycoord = op1.ycoord * scale;
00169 return result;
00170 }
00171
00172
00173 inline ICOORD operator *(
00174 inT16 scale,
00175 const ICOORD &op1
00176 ) {
00177 ICOORD result;
00178
00179 result.xcoord = op1.xcoord * scale;
00180 result.ycoord = op1.ycoord * scale;
00181 return result;
00182 }
00183
00184
00185
00186
00187
00188
00189
00190
00191 inline ICOORD &
00192 operator*= (
00193 ICOORD & op1,
00194 inT16 scale) {
00195 op1.xcoord *= scale;
00196 op1.ycoord *= scale;
00197 return op1;
00198 }
00199
00200
00201
00202
00203
00204
00205
00206
00207 inline ICOORD
00208 operator/ (
00209 const ICOORD & op1,
00210 inT16 scale) {
00211 ICOORD result;
00212
00213 result.xcoord = op1.xcoord / scale;
00214 result.ycoord = op1.ycoord / scale;
00215 return result;
00216 }
00217
00218
00219
00220
00221
00222
00223
00224
00225 inline ICOORD &
00226 operator/= (
00227 ICOORD & op1,
00228 inT16 scale) {
00229 op1.xcoord /= scale;
00230 op1.ycoord /= scale;
00231 return op1;
00232 }
00233
00234
00235
00236
00237
00238
00239
00240
00241 inline void ICOORD::rotate(
00242 const FCOORD& vec) {
00243 inT16 tmp;
00244
00245 tmp = (inT16) floor (xcoord * vec.x () - ycoord * vec.y () + 0.5);
00246 ycoord = (inT16) floor (ycoord * vec.x () + xcoord * vec.y () + 0.5);
00247 xcoord = tmp;
00248 }
00249
00250
00251
00252
00253
00254
00255
00256
00257 inline FCOORD
00258 operator! (
00259 const FCOORD & src
00260 ) {
00261 FCOORD result;
00262
00263 result.xcoord = -src.ycoord;
00264 result.ycoord = src.xcoord;
00265 return result;
00266 }
00267
00268
00269
00270
00271
00272
00273
00274
00275 inline FCOORD
00276 operator- (
00277 const FCOORD & src
00278 ) {
00279 FCOORD result;
00280
00281 result.xcoord = -src.xcoord;
00282 result.ycoord = -src.ycoord;
00283 return result;
00284 }
00285
00286
00287
00288
00289
00290
00291
00292
00293 inline FCOORD
00294 operator+ (
00295 const FCOORD & op1,
00296 const FCOORD & op2) {
00297 FCOORD sum;
00298
00299 sum.xcoord = op1.xcoord + op2.xcoord;
00300 sum.ycoord = op1.ycoord + op2.ycoord;
00301 return sum;
00302 }
00303
00304
00305
00306
00307
00308
00309
00310
00311 inline FCOORD &
00312 operator+= (
00313 FCOORD & op1,
00314 const FCOORD & op2) {
00315 op1.xcoord += op2.xcoord;
00316 op1.ycoord += op2.ycoord;
00317 return op1;
00318 }
00319
00320
00321
00322
00323
00324
00325
00326
00327 inline FCOORD
00328 operator- (
00329 const FCOORD & op1,
00330 const FCOORD & op2) {
00331 FCOORD sum;
00332
00333 sum.xcoord = op1.xcoord - op2.xcoord;
00334 sum.ycoord = op1.ycoord - op2.ycoord;
00335 return sum;
00336 }
00337
00338
00339
00340
00341
00342
00343
00344
00345 inline FCOORD &
00346 operator-= (
00347 FCOORD & op1,
00348 const FCOORD & op2) {
00349 op1.xcoord -= op2.xcoord;
00350 op1.ycoord -= op2.ycoord;
00351 return op1;
00352 }
00353
00354
00355
00356
00357
00358
00359
00360
00361 inline float
00362 operator% (
00363 const FCOORD & op1,
00364 const FCOORD & op2) {
00365 return op1.xcoord * op2.xcoord + op1.ycoord * op2.ycoord;
00366 }
00367
00368
00369
00370
00371
00372
00373
00374
00375 inline float operator *(
00376 const FCOORD &op1,
00377 const FCOORD &op2) {
00378 return op1.xcoord * op2.ycoord - op1.ycoord * op2.xcoord;
00379 }
00380
00381
00382
00383
00384
00385
00386
00387
00388 inline FCOORD operator *(
00389 const FCOORD &op1,
00390 float scale) {
00391 FCOORD result;
00392
00393 result.xcoord = op1.xcoord * scale;
00394 result.ycoord = op1.ycoord * scale;
00395 return result;
00396 }
00397
00398
00399 inline FCOORD operator *(
00400 float scale,
00401 const FCOORD &op1
00402 ) {
00403 FCOORD result;
00404
00405 result.xcoord = op1.xcoord * scale;
00406 result.ycoord = op1.ycoord * scale;
00407 return result;
00408 }
00409
00410
00411
00412
00413
00414
00415
00416
00417 inline FCOORD &
00418 operator*= (
00419 FCOORD & op1,
00420 float scale) {
00421 op1.xcoord *= scale;
00422 op1.ycoord *= scale;
00423 return op1;
00424 }
00425
00426
00427
00428
00429
00430
00431
00432
00433 inline FCOORD
00434 operator/ (
00435 const FCOORD & op1,
00436 float scale) {
00437 FCOORD result;
00438
00439 if (scale != 0) {
00440 result.xcoord = op1.xcoord / scale;
00441 result.ycoord = op1.ycoord / scale;
00442 }
00443 return result;
00444 }
00445
00446
00447
00448
00449
00450
00451
00452
00453 inline FCOORD &
00454 operator/= (
00455 FCOORD & op1,
00456 float scale) {
00457 if (scale != 0) {
00458 op1.xcoord /= scale;
00459 op1.ycoord /= scale;
00460 }
00461 return op1;
00462 }
00463
00464
00465
00466
00467
00468
00469
00470
00471 inline void FCOORD::rotate(
00472 const FCOORD vec) {
00473 float tmp;
00474
00475 tmp = xcoord * vec.x () - ycoord * vec.y ();
00476 ycoord = ycoord * vec.x () + xcoord * vec.y ();
00477 xcoord = tmp;
00478 }
00479 #endif