DisplayShape.h

Go to the documentation of this file.

//# DisplayShape.h: Abstract base class for all shapes/annotations objects
//# Copyright (C) 1998,1999,2000,2001,2002
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id:

#ifndef TRIALDISPLAY_DISPLAYSHAPE_H
#define TRIALDISPLAY_DISPLAYSHAPE_H

#include <casa/aips.h>
#include <casa/Arrays/Matrix.h>
#include <casa/Containers/Record.h>

namespace casa { //# NAMESPACE CASA - BEGIN

        class DSShape;
        class DSClosed;
        class DisplayEnums;
        class PixelCanvas;
        class DParameterColorChoice;


// <summary>
// The abstract base class for all "DisplayShapes".
// </summary>
//
// <prerequisite>
// </prerequisite>
//
// <etymology>
// DisplayShape is a way of providing a consistant interface to a large number
// of different shapes.
// </etymology>
//
// <synopsis>
// DisplayShape provides a framework from which a large number of different
// shapes can be made, all with the same interface. Any new DisplayShape
// should inherit from this class, or higher level classes
// (see <linkto class="DSPoly">DSPoly</linkto> etc).
//
// There are generally two ways to make DisplayShape(s); To create them in
// "one hit" by providing arguments to the constructor, or by using the
// default constructor and then the "setOptions" method. A simple interface
// for all classes inheriting from the
// <linkto class="DisplayShape">DisplayShape</linkto> class is provided
// by <linkto class="DisplayShapeInterface">DisplayShapeInterface</linkto>.
// </synopsis>
//
// <motivation>
// A common interface to a large number of shapes was desired.
// </motivation>
//
// <example>
// </example>

        class DisplayShape {

        public:
                // Handle style
                enum HandleShape {Filled_Square=0, Open_Square, Filled_Circle,
                                  Open_Circle, Filled_Triangle, Open_Triangle
                                 };


                // Default constructor. Creates shape with default options set
                DisplayShape();
                // Copy constructor
                DisplayShape(const DisplayShape& other);
                // Destructor
                virtual ~DisplayShape();

                // These functions contol behaviour of handles during a call
                // to the display shape object.
                // (These calls should be propogated up through the class tree).
                // <group>
                virtual void draw(PixelCanvas* pc);
                virtual void rotateAbout(const Float& relAngle, const Float& aboutX,
                                         const Float& aboutY) ;
                virtual void move(const Float& dX, const Float& dY);
                // </group>


                // Rotate the supplied polygon (column 1 - x values, column 2 - y values)
                // about the supplied point by the supplied angle. NB Angle in radians
                virtual Matrix<Float> rotatePolygon(const Matrix<Float>& toRotate,
                                                    const Float& angle,
                                                    const Float& aboutX,
                                                    const Float& aboutY);

                // Rotates a point around the point specified. NB Angle in radians.
                virtual Vector<Float> rotatePoint(const Vector<Float>& toRotate,
                                                  const Float& angle,
                                                  const Float& aboutX, const Float& aboutY);

                // Translate an entire matrix by the specified dx / dy amounts.
                virtual Matrix<Float> translateMatrix(const Matrix<Float>& points,
                                                      const Float& dx, const Float& dy);

                // Is xPos, YPos inside the supplied points (column 1 - x values,
                // clolumn 2 - y values)
                virtual Bool inPolygon(const Matrix<Float>& points, const Float& xPos,
                                       const Float& yPos);

                // Determine the two vertices (firstVert, secondVert) which join the line
                // closest to the xPos, yPos point supplied. If closedPoly is left as
                // true, the points supplied are treated as a polygon, if not as a poly
                // line.
                virtual Bool closestLine(const Matrix<Float>& points, const Float& xPos,
                                         const Float& yPos,
                                         Int& firstVert, Int& secondVert,
                                         const Bool& closedPoly = True);

                // For a specified set of points, find the closest to xPos,YPos. out
                // relates the matrix index (row number) of the closest point.
                virtual Bool closestPoint(const Matrix<Float>& points,
                                          const Float& xPos, const Float& yPos,
                                          Int& out);

                // Find the closest two Points from a Matrix to the specified point.
                virtual Bool closestPoints(const Matrix<Float>& points,
                                           const Float& xPos, const Float& yPos,
                                           Int& outClosest, Int& outSecond);

                // Is the supplied point within the DisplayShape?
                virtual Bool inObject(const Float& xPos, const Float& yPos) = 0;

                // Convert degrees to radians
                virtual Float toRadians(const Float& degrees);

                // Conver radians to degree
                virtual Float toDegrees(const Float& radians);

                // Sets the center of the DisplayShape
                virtual void setCenter(const Float& xPos, const Float& yPos) = 0;

                // Returns the center of the DisplayShape (x,y).
                virtual Vector<Float> getCenter() = 0;

                // Changes the closest point to the supplied location to that location
                virtual void changePoint(const Vector<Float>& newPos) = 0;

                // Changes the nth point making up the DisplayShape ot the specified
                // location.
                virtual void changePoint(const Vector<Float>& newPoint,
                                         const Int nPoint) = 0;

                // If applicable, this function will add a point to the shape in the
                // most meaningful location.
                virtual void addPoint(const Vector<Float>& /*newPoint*/) { };

                // Rotate the shape about its center by a set angle (angle in degrees).
                virtual void rotate(const Float& angle) = 0;

                // Scale the shape about its center by the scaleFactor
                virtual void scale(const Float& scaleFactor) = 0;

                // Allow locking of other shapes onto this one. When a shape is locked,
                // if the current shape is moved, so to will the locked shape.
                virtual void addLocked(DisplayShape* toLock);

                // Removes a lock from the specified shape.
                virtual void removeLocked(DisplayShape* removeLock);

                // Handle management.
                // <group>
                virtual void buildHandles(const Matrix<Float>& startPoints);
                virtual Matrix<Float> getHandleLocations();
                virtual void setHandlePositions(const Matrix<Float>& newPoints);
                virtual DSClosed*  makeHandle(const Vector<Float>& newHandlePos);
                virtual void addHandle(const Vector<Float>& newHandlePos,
                                       const Bool& atEnd = True
                                               , const Int position = 0);
                virtual Bool removeHandle(const Vector<Float>& getRidOf);
                virtual Bool removeHandle(const Int nHandle);

                virtual Bool onHandles(const Float& xPos, const Float& yPos);
                virtual Bool whichHandle(const Float& xPos, const Float& yPos, Int& out);

                virtual void setDrawHandles(const Bool& shouldIDraw);
                virtual Bool drawingHandles() {
                        return itsDrawHandles;
                }
                virtual void setHasHandles(const Bool& hasHandles);
                virtual void setHandleShape(const DisplayShape::HandleShape& shape);
                virtual void setHandleSize(const Int pixelSize);
                virtual void setHandleColor(const String& handleColor);
                virtual uInt nHandles();
                // </group>

                // Manage the color of object. (Does not include handles)
                // <group>
                virtual void setColor(const String& newColor);
                virtual String getColor();
                // </group>

                // Settings
                // <group>
                virtual Record getOptions();
                virtual Bool setOptions(const Record& settings);
                // </group>

                virtual void recalculateScreenPosition() {}

        private:
                // Set default options
                virtual void setDefaultOptions();


                // Object
                DParameterColorChoice* itsColor;

                // Handles
                PtrBlock<DSClosed*> itsHandles;

                // Locks
                PtrBlock<DisplayShape*> itsLocks;

                // Do I have handles / can a user resize me?
                // i.e. Do I *ever* want to draw handles (e.g. will be false for an object
                //      which IS a handle!)
                Bool itsHasHandles;

                // Should handles be shown if they exist
                Bool itsDrawHandles;

                // Have valid handles been made/supplied yet?
                Bool itsValidHandles;

                // Handle settings
                // <group>
                String itsHandleColor;
                DisplayShape::HandleShape itsHandleShape;
                Int itsHandleSize;
                // </group>

        };

} //# NAMESPACE CASA - END

#endif