javax.vecmath/src/javax/vecmath/Point2f.java

   1 /*
   2  * $RCSfile: Point2f.java,v $
   3  *
   4  * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
   5  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   6  *
   7  * This code is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 only, as
   9  * published by the Free Software Foundation.  Sun designates this
  10  * particular file as subject to the "Classpath" exception as provided
  11  * by Sun in the LICENSE file that accompanied this code.
  12  *
  13  * This code is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16  * version 2 for more details (a copy is included in the LICENSE file that
  17  * accompanied this code).
  18  *
  19  * You should have received a copy of the GNU General Public License version
  20  * 2 along with this work; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  22  *
  23  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  24  * CA 95054 USA or visit www.sun.com if you need additional information or
  25  * have any questions.
  26  *
  27  * $Revision: 1.5 $
  28  * $Date: 2008/02/28 20:18:50 $
  29  * $State: Exp $
  30  */
  31
  32 package javax.vecmath;
  33
  34 import java.lang.Math;
  35
  36 /**
  37  * A 2 element point that is represented by single precision floating
  38  * point x,y coordinates.
  39  *
  40  */
  41 public class Point2f extends Tuple2f implements java.io.Serializable {
  42
  43     // Compatible with 1.1
  44     static final long serialVersionUID = -4801347926528714435L;
  45
  46     /**
  47      * Constructs and initializes a Point2f from the specified xy coordinates.
  48      * @param x the x coordinate
  49      * @param y the y coordinate
  50      */
  51     public Point2f(float x, float y)
  52     {
  53          super(x,y);
  54     }
  55
  56
  57     /**
  58      * Constructs and initializes a Point2f from the specified array.
  59      * @param p the array of length 2 containing xy in order
  60      */
  61     public Point2f(float[] p)
  62     {
  63          super(p);
  64     }
  65
  66
  67     /**
  68      * Constructs and initializes a Point2f from the specified Point2f.
  69      * @param p1 the Point2f containing the initialization x y data
  70      */
  71     public Point2f(Point2f p1)
  72     {
  73         super(p1);
  74     }
  75
  76     /**
  77      * Constructs and initializes a Point2f from the specified Point2d.
  78      * @param p1 the Point2d containing the initialization x y z data
  79      */
  80     public Point2f(Point2d p1)
  81     {
  82        super(p1);
  83     }
  84
  85
  86
  87     /**
  88      * Constructs and initializes a Point2f from the specified Tuple2d.
  89      * @param t1 the Tuple2d containing the initialization x y z data
  90      */
  91     public Point2f(Tuple2d t1)
  92     {
  93        super(t1);
  94     }
  95
  96
  97
  98     /**
  99      * Constructs and initializes a Point2f from the specified Tuple2f.
 100      * @param t1 the Tuple2f containing the initialization x y data
 101      */
 102     public Point2f(Tuple2f t1)
 103     {
 104        super(t1);
 105     }
 106
 107
 108     /**
 109      * Constructs and initializes a Point2f to (0,0).
 110      */
 111     public Point2f()
 112     {
 113        super();
 114     }
 115
 116   /**
 117    * Computes the square of the distance between this point and point p1.
 118    * @param p1 the other point
 119    */
 120   public final float distanceSquared(Point2f p1)
 121     {
 122       float dx, dy;
 123
 124       dx = this.x-p1.x;
 125       dy = this.y-p1.y;
 126       return dx*dx+dy*dy;
 127     }
 128
 129   /**
 130    * Computes the distance between this point and point p1.
 131    * @param p1 the other point
 132    */
 133   public final float distance(Point2f p1)
 134     {
 135       float  dx, dy;
 136
 137       dx = this.x-p1.x;
 138       dy = this.y-p1.y;
 139       return (float) Math.sqrt(dx*dx+dy*dy);
 140     }
 141
 142
 143   /**
 144     * Computes the L-1 (Manhattan) distance between this point and
 145     * point p1.  The L-1 distance is equal to abs(x1-x2) + abs(y1-y2).
 146     * @param p1 the other point
 147     */
 148   public final float distanceL1(Point2f p1)
 149     {
 150       return( Math.abs(this.x-p1.x) + Math.abs(this.y-p1.y));
 151     }
 152
 153   /**
 154     * Computes the L-infinite distance between this point and
 155     * point p1.  The L-infinite distance is equal to
 156     * MAX[abs(x1-x2), abs(y1-y2)].
 157     * @param p1 the other point
 158     */
 159   public final float distanceLinf(Point2f p1)
 160     {
 161       return(Math.max( Math.abs(this.x-p1.x), Math.abs(this.y-p1.y)));
 162     }
 163
 164 }