| /********************************************************************** |
| * File: points.h (Formerly coords.h) |
| * Description: Coordinate class definitions. |
| * Author: Ray Smith |
| * Created: Fri Mar 15 08:32:45 GMT 1991 |
| * |
| * (C) Copyright 1991, Hewlett-Packard Ltd. |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| * |
| **********************************************************************/ |
| |
| #ifndef POINTS_H |
| #define POINTS_H |
| |
| #include <stdio.h> |
| #include <math.h> |
| #include "elst.h" |
| //#include "ipeerr.h" |
| |
| class FCOORD; |
| |
| class DLLSYM ICOORD //integer coordinate |
| { |
| friend class FCOORD; |
| |
| public: |
| ICOORD() { //empty constructor |
| xcoord = ycoord = 0; //default zero |
| } |
| ICOORD( //constructor |
| inT16 xin, //x value |
| inT16 yin) { //y value |
| xcoord = xin; |
| ycoord = yin; |
| } |
| ~ICOORD () { //destructor |
| } |
| |
| //access function |
| NEWDELETE2 (ICOORD) inT16 x () const |
| { |
| return xcoord; |
| } |
| inT16 y() const { //access_function |
| return ycoord; |
| } |
| |
| void set_x( //rewrite function |
| inT16 xin) { |
| xcoord = xin; //write new value |
| } |
| void set_y( //rewrite function |
| inT16 yin) { //value to set |
| ycoord = yin; |
| } |
| |
| // Set from the given x,y, shrinking the vector to fit if needed. |
| void set_with_shrink(int x, int y); |
| |
| float sqlength() const { //find sq length |
| return (float) (xcoord * xcoord + ycoord * ycoord); |
| } |
| |
| float length() const { //find length |
| return (float) sqrt (sqlength ()); |
| } |
| |
| float pt_to_pt_sqdist( //sq dist between pts |
| const ICOORD &pt) const { |
| ICOORD gap; |
| |
| gap.xcoord = xcoord - pt.xcoord; |
| gap.ycoord = ycoord - pt.ycoord; |
| return gap.sqlength (); |
| } |
| |
| float pt_to_pt_dist( //Distance between pts |
| const ICOORD &pt) const { |
| return (float) sqrt (pt_to_pt_sqdist (pt)); |
| } |
| |
| float angle() const { //find angle |
| return (float) atan2 ((double) ycoord, (double) xcoord); |
| } |
| |
| BOOL8 operator== ( //test equality |
| const ICOORD & other) { |
| return xcoord == other.xcoord && ycoord == other.ycoord; |
| } |
| BOOL8 operator!= ( //test inequality |
| const ICOORD & other) { |
| return xcoord != other.xcoord || ycoord != other.ycoord; |
| } |
| friend ICOORD operator! ( //rotate 90 deg anti |
| const ICOORD &); |
| friend ICOORD operator- ( //unary minus |
| const ICOORD &); |
| friend ICOORD operator+ ( //add |
| const ICOORD &, const ICOORD &); |
| friend ICOORD & operator+= ( //add |
| ICOORD &, const ICOORD &); |
| friend ICOORD operator- ( //subtract |
| const ICOORD &, const ICOORD &); |
| friend ICOORD & operator-= ( //subtract |
| ICOORD &, const ICOORD &); |
| friend inT32 operator% ( //scalar product |
| const ICOORD &, const ICOORD &); |
| friend inT32 operator *( //cross product |
| const ICOORD &, |
| const ICOORD &); |
| friend ICOORD operator *( //multiply |
| const ICOORD &, |
| inT16); |
| friend ICOORD operator *( //multiply |
| inT16, |
| const ICOORD &); |
| friend ICOORD & operator*= ( //multiply |
| ICOORD &, inT16); |
| friend ICOORD operator/ ( //divide |
| const ICOORD &, inT16); |
| //divide |
| friend ICOORD & operator/= (ICOORD &, inT16); |
| void rotate( //rotate |
| const FCOORD& vec); //by vector |
| |
| // Setup for iterating over the pixels in a vector by the well-known |
| // Bresenham rendering algorithm. |
| // Starting with major/2 in the accumulator, on each step move by |
| // major_step, and then add minor to the accumulator. When |
| // accumulator >= major subtract major and also move by minor_step. |
| void setup_render(ICOORD* major_step, ICOORD* minor_step, |
| int* major, int* minor) const; |
| |
| void serialise_asc( //serialise to ascii |
| FILE *f); |
| void de_serialise_asc( //serialise from ascii |
| FILE *f); |
| |
| protected: |
| inT16 xcoord; //x value |
| inT16 ycoord; //y value |
| }; |
| |
| class DLLSYM ICOORDELT:public ELIST_LINK, public ICOORD |
| //embedded coord list |
| { |
| public: |
| ICOORDELT() { //empty constructor |
| } |
| ICOORDELT ( //constructor |
| //from ICOORD |
| ICOORD icoord):ICOORD (icoord) { |
| } |
| ICOORDELT( //constructor |
| inT16 xin, //x value |
| inT16 yin) { //y value |
| xcoord = xin; |
| ycoord = yin; |
| } |
| |
| /* Note that prep_serialise() dump() and de_dump() dont need to do anything |
| more than terminate recursion. */ |
| |
| void prep_serialise() const { //set ptrs to counts |
| } |
| |
| void dump( //write external bits |
| FILE *) const { |
| } |
| |
| void de_dump( //read external bits |
| FILE *) { |
| } |
| |
| //serialise to ascii |
| make_serialise(ICOORDELT) |
| |
| static ICOORDELT* deep_copy(const ICOORDELT* src) { |
| ICOORDELT* elt = new ICOORDELT; |
| *elt = *src; |
| return elt; |
| } |
| |
| void serialise_asc(FILE * f); |
| void de_serialise_asc( //serialise from ascii |
| FILE *f); |
| |
| }; |
| |
| ELISTIZEH_S (ICOORDELT) |
| class DLLSYM FCOORD |
| { |
| public: |
| FCOORD() { |
| } //empty constructor |
| FCOORD( //constructor |
| float xvalue, //coords to set |
| float yvalue) { |
| xcoord = xvalue; //set coords |
| ycoord = yvalue; |
| } |
| FCOORD( //make from ICOORD |
| ICOORD icoord) { //coords to set |
| xcoord = icoord.xcoord; |
| ycoord = icoord.ycoord; |
| } |
| |
| float x() const { //get coords |
| return xcoord; |
| } |
| float y() const { |
| return ycoord; |
| } |
| void set_x( //rewrite function |
| float xin) { |
| xcoord = xin; //write new value |
| } |
| void set_y( //rewrite function |
| float yin) { //value to set |
| ycoord = yin; |
| } |
| |
| float sqlength() const { //find sq length |
| return xcoord * xcoord + ycoord * ycoord; |
| } |
| |
| float length() const { //find length |
| return (float) sqrt (sqlength ()); |
| } |
| |
| float pt_to_pt_sqdist( //sq dist between pts |
| const FCOORD &pt) const { |
| FCOORD gap; |
| |
| gap.xcoord = xcoord - pt.xcoord; |
| gap.ycoord = ycoord - pt.ycoord; |
| return gap.sqlength (); |
| } |
| |
| float pt_to_pt_dist( //Distance between pts |
| const FCOORD &pt) const { |
| return (float) sqrt (pt_to_pt_sqdist (pt)); |
| } |
| |
| float angle() const { //find angle |
| return (float) atan2 (ycoord, xcoord); |
| } |
| |
| bool normalise(); //Convert to unit vec |
| |
| BOOL8 operator== ( //test equality |
| const FCOORD & other) { |
| return xcoord == other.xcoord && ycoord == other.ycoord; |
| } |
| BOOL8 operator!= ( //test inequality |
| const FCOORD & other) { |
| return xcoord != other.xcoord || ycoord != other.ycoord; |
| } |
| //rotate 90 deg anti |
| friend FCOORD operator! (const FCOORD &); |
| //unary minus |
| friend FCOORD operator- (const FCOORD &); |
| //add |
| friend FCOORD operator+ (const FCOORD &, const FCOORD &); |
| //add |
| friend FCOORD & operator+= (FCOORD &, const FCOORD &); |
| //subtract |
| friend FCOORD operator- (const FCOORD &, const FCOORD &); |
| //subtract |
| friend FCOORD & operator-= (FCOORD &, const FCOORD &); |
| //scalar product |
| friend float operator% (const FCOORD &, const FCOORD &); |
| //cross product |
| friend float operator *(const FCOORD &, const FCOORD &); |
| friend FCOORD operator *(const FCOORD &, float); |
| //multiply |
| friend FCOORD operator *(float, const FCOORD &); |
| //multiply |
| //multiply |
| friend FCOORD & operator*= (FCOORD &, float); |
| friend FCOORD operator/ (const FCOORD &, float); |
| //divide |
| void rotate( //rotate |
| const FCOORD vec); //by vector |
| //divide |
| friend FCOORD & operator/= (FCOORD &, float); |
| |
| private: |
| float xcoord; //2 floating coords |
| float ycoord; |
| }; |
| |
| #include "ipoints.h" /*do inline funcs */ |
| #endif |